@haex-space/vault-sdk 1.0.0

package/dist/runtime/nuxt.plugin.client.js

@@ -0,0 +1,1137 @@
+'use strict';
+
+var app = require('nuxt/app');
+var vue = require('vue');
+var sqliteProxy = require('drizzle-orm/sqlite-proxy');
+
+// src/runtime/nuxt.plugin.client.ts
+
+// src/events.ts
+var HAEXTENSION_EVENTS = {
+  /** Context (theme, locale, platform) has changed */
+  CONTEXT_CHANGED: "haextension:context:changed",
+  /** Search request from HaexHub */
+  SEARCH_REQUEST: "haextension:search:request"
+};
+
+// src/methods.ts
+var HAEXTENSION_METHODS = {
+  context: {
+    get: "haextension:context:get"
+  },
+  database: {
+    query: "haextension:database:query",
+    execute: "haextension:database:execute",
+    transaction: "haextension:database:transaction",
+    registerMigrations: "haextension:database:register-migrations"
+  },
+  filesystem: {
+    saveFile: "haextension:filesystem:save-file",
+    openFile: "haextension:filesystem:open-file",
+    showImage: "haextension:filesystem:show-image"
+  },
+  storage: {
+    getItem: "haextension:storage:get-item",
+    setItem: "haextension:storage:set-item",
+    removeItem: "haextension:storage:remove-item",
+    clear: "haextension:storage:clear",
+    keys: "haextension:storage:keys"
+  },
+  web: {
+    fetch: "haextension:web:fetch"
+  },
+  application: {
+    open: "haextension:application:open"
+  }
+};
+
+// src/types.ts
+var DEFAULT_TIMEOUT = 3e4;
+var TABLE_SEPARATOR = "__";
+var HaexHubError = class extends Error {
+  constructor(code, messageKey, details) {
+    super(messageKey);
+    this.code = code;
+    this.messageKey = messageKey;
+    this.details = details;
+    this.name = "HaexHubError";
+  }
+  /**
+   * Get localized error message
+   * @param locale - Locale code (e.g., 'en', 'de')
+   * @param translations - Translation object
+   */
+  getLocalizedMessage(locale = "en", translations) {
+    if (!translations || !translations[locale]) {
+      return this.messageKey;
+    }
+    let message = translations[locale][this.messageKey] || this.messageKey;
+    if (this.details) {
+      Object.entries(this.details).forEach(([key, value]) => {
+        message = message.replace(`{${key}}`, String(value));
+      });
+    }
+    return message;
+  }
+  toJSON() {
+    return {
+      code: this.code,
+      message: this.messageKey,
+      details: this.details
+    };
+  }
+};
+
+// src/api/storage.ts
+var StorageAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async getItem(key) {
+    return this.client.request(HAEXTENSION_METHODS.storage.getItem, { key });
+  }
+  async setItem(key, value) {
+    await this.client.request(HAEXTENSION_METHODS.storage.setItem, { key, value });
+  }
+  async removeItem(key) {
+    await this.client.request(HAEXTENSION_METHODS.storage.removeItem, { key });
+  }
+  async clear() {
+    await this.client.request(HAEXTENSION_METHODS.storage.clear);
+  }
+  async keys() {
+    return this.client.request(HAEXTENSION_METHODS.storage.keys);
+  }
+};
+
+// src/api/database.ts
+var DatabaseAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async query(query, params) {
+    const result = await this.client.request(
+      HAEXTENSION_METHODS.database.query,
+      {
+        query,
+        params: params || []
+      }
+    );
+    return result.rows;
+  }
+  async queryOne(query, params) {
+    const rows = await this.query(query, params);
+    return rows.length > 0 ? rows[0] ?? null : null;
+  }
+  async execute(query, params) {
+    return this.client.request(HAEXTENSION_METHODS.database.execute, {
+      query,
+      params: params || []
+    });
+  }
+  async transaction(statements) {
+    await this.client.request(HAEXTENSION_METHODS.database.transaction, {
+      statements
+    });
+  }
+  async createTable(tableName, columns) {
+    const query = `CREATE TABLE IF NOT EXISTS ${tableName} (${columns})`;
+    await this.execute(query);
+  }
+  async dropTable(tableName) {
+    const query = `DROP TABLE IF EXISTS ${tableName}`;
+    await this.execute(query);
+  }
+  /**
+   * Registers extension migrations with HaexVault for CRDT synchronization
+   * HaexVault will validate and execute these migrations, ensuring only
+   * tables with the correct prefix are manipulated
+   * @param extensionVersion - The version of the extension
+   * @param migrations - Array of migration objects with name and SQL content
+   * @returns Promise that resolves when migrations are registered
+   */
+  async registerMigrationsAsync(extensionVersion, migrations) {
+    await this.client.request(HAEXTENSION_METHODS.database.registerMigrations, {
+      extensionVersion,
+      migrations
+    });
+  }
+  async insert(tableName, data) {
+    const keys = Object.keys(data);
+    const values = Object.values(data);
+    const placeholders = keys.map(() => "?").join(", ");
+    const query = `INSERT INTO ${tableName} (${keys.join(
+      ", "
+    )}) VALUES (${placeholders})`;
+    const result = await this.execute(query, values);
+    return result.lastInsertId ?? -1;
+  }
+  async update(tableName, data, where, whereParams) {
+    const keys = Object.keys(data);
+    const values = Object.values(data);
+    const setClause = keys.map((key) => `${key} = ?`).join(", ");
+    const query = `UPDATE ${tableName} SET ${setClause} WHERE ${where}`;
+    const result = await this.execute(query, [
+      ...values,
+      ...whereParams || []
+    ]);
+    return result.rowsAffected;
+  }
+  async delete(tableName, where, whereParams) {
+    const query = `DELETE FROM ${tableName} WHERE ${where}`;
+    const result = await this.execute(query, whereParams);
+    return result.rowsAffected;
+  }
+  async count(tableName, where, whereParams) {
+    const query = where ? `SELECT COUNT(*) as count FROM ${tableName} WHERE ${where}` : `SELECT COUNT(*) as count FROM ${tableName}`;
+    const result = await this.queryOne(query, whereParams);
+    return result?.count ?? 0;
+  }
+};
+
+// src/api/filesystem.ts
+var FilesystemAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Opens a save file dialog and saves the provided data to the selected location
+   * @param data The file data as Uint8Array
+   * @param options Options for the save dialog
+   * @returns The path where the file was saved, or null if cancelled
+   */
+  async saveFileAsync(data, options = {}) {
+    const result = await this.client.request(
+      HAEXTENSION_METHODS.filesystem.saveFile,
+      {
+        data: Array.from(data),
+        // Convert Uint8Array to regular array for postMessage
+        defaultPath: options.defaultPath,
+        title: options.title,
+        filters: options.filters
+      }
+    );
+    return result;
+  }
+  /**
+   * Opens a file with the system's default viewer
+   * @param data The file data as Uint8Array
+   * @param options Options for opening the file
+   * @returns The result of the operation
+   */
+  async openFileAsync(data, options) {
+    const result = await this.client.request(
+      HAEXTENSION_METHODS.filesystem.openFile,
+      {
+        data: Array.from(data),
+        // Convert Uint8Array to regular array for postMessage
+        fileName: options.fileName,
+        mimeType: options.mimeType
+      }
+    );
+    return result;
+  }
+  /**
+   * Shows an image using a data URL (safe, read-only viewing)
+   * This is safe to use without special permissions as it only displays images
+   * and doesn't execute any code or open files with external applications
+   * @param options Options containing the data URL
+   * @returns The result of the operation
+   */
+  async showImageAsync(options) {
+    const result = await this.client.request(
+      HAEXTENSION_METHODS.filesystem.showImage,
+      {
+        dataUrl: options.dataUrl
+      }
+    );
+    return result;
+  }
+};
+
+// src/api/web.ts
+var WebAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Performs a web request through the HaexHub host application
+   * @param url The URL to fetch
+   * @param options Request options (method, headers, body, timeout)
+   * @returns Promise resolving to the web response
+   */
+  async fetchAsync(url, options = {}) {
+    let bodyParam;
+    if (options.body) {
+      if (options.body instanceof ArrayBuffer) {
+        bodyParam = this.arrayBufferToBase64(options.body);
+      } else if (options.body instanceof Blob) {
+        bodyParam = await this.blobToBase64(options.body);
+      } else {
+        bodyParam = options.body;
+      }
+    }
+    const response = await this.client.request(HAEXTENSION_METHODS.web.fetch, {
+      url,
+      method: options.method || "GET",
+      headers: options.headers,
+      body: bodyParam,
+      timeout: options.timeout
+    });
+    const bodyBuffer = this.base64ToArrayBuffer(response.body);
+    return {
+      status: response.status,
+      statusText: response.statusText,
+      headers: response.headers,
+      body: bodyBuffer,
+      url: response.url
+    };
+  }
+  /**
+   * Convenience method for JSON requests
+   */
+  async fetchJsonAsync(url, options = {}) {
+    const response = await this.fetchAsync(url, options);
+    const text = new TextDecoder().decode(response.body);
+    return JSON.parse(text);
+  }
+  /**
+   * Convenience method for text requests
+   */
+  async fetchTextAsync(url, options = {}) {
+    const response = await this.fetchAsync(url, options);
+    return new TextDecoder().decode(response.body);
+  }
+  /**
+   * Convenience method for blob requests
+   */
+  async fetchBlobAsync(url, options = {}) {
+    const response = await this.fetchAsync(url, options);
+    return new Blob([response.body]);
+  }
+  /**
+   * Opens a URL in the user's default browser
+   * @param url The URL to open
+   */
+  async openAsync(url) {
+    await this.client.request(HAEXTENSION_METHODS.application.open, {
+      application: "browser",
+      url
+    });
+  }
+  arrayBufferToBase64(buffer) {
+    const bytes = new Uint8Array(buffer);
+    let binary = "";
+    for (let i = 0; i < bytes.byteLength; i++) {
+      const byte = bytes[i];
+      if (byte === void 0) {
+        throw new Error("Invalid byte at index " + i);
+      }
+      binary += String.fromCharCode(byte);
+    }
+    return btoa(binary);
+  }
+  async blobToBase64(blob) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onloadend = () => {
+        const result = reader.result;
+        if (typeof result !== "string") {
+          reject(new Error("Failed to read blob as data URL"));
+          return;
+        }
+        const parts = result.split(",");
+        const base64 = parts[1];
+        if (!base64) {
+          reject(new Error("Failed to extract base64 from data URL"));
+          return;
+        }
+        resolve(base64);
+      };
+      reader.onerror = reject;
+      reader.readAsDataURL(blob);
+    });
+  }
+  base64ToArrayBuffer(base64) {
+    const binaryString = atob(base64);
+    const bytes = new Uint8Array(binaryString.length);
+    for (let i = 0; i < binaryString.length; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return bytes.buffer;
+  }
+};
+
+// src/api/permissions.ts
+var PermissionsAPI = class {
+  constructor(client) {
+    this.client = client;
+  }
+  /**
+   * Checks if the extension has permission for a database operation
+   * @param resource The database resource (table name or "*" for all tables)
+   * @param operation The operation type ("read" or "write")
+   * @returns Promise<boolean> indicating if permission is granted
+   */
+  async checkDatabaseAsync(resource, operation) {
+    const response = await this.client.request(
+      "permissions.database.check",
+      {
+        resource,
+        operation
+      }
+    );
+    return response.status === "granted";
+  }
+  /**
+   * Checks if the extension has permission for a web request
+   * @param url The URL to check (e.g., "https://example.com/path")
+   * @returns Promise<boolean> indicating if permission is granted
+   * @note Method/operation is not checked - permissions apply to all HTTP methods
+   */
+  async checkWebAsync(url) {
+    const response = await this.client.request(
+      "permissions.web.check",
+      {
+        url
+      }
+    );
+    return response.status === "granted";
+  }
+  /**
+   * Checks if the extension has permission for a filesystem operation
+   * @param path The file or directory path
+   * @param operation The operation type ("read" or "write")
+   * @returns Promise<boolean> indicating if permission is granted
+   */
+  async checkFilesystemAsync(path, operation) {
+    const response = await this.client.request(
+      "permissions.filesystem.check",
+      {
+        path,
+        operation
+      }
+    );
+    return response.status === "granted";
+  }
+};
+
+// src/polyfills/consoleForwarding.ts
+var originalConsole = {
+  log: console.log,
+  info: console.info,
+  warn: console.warn,
+  error: console.error,
+  debug: console.debug
+};
+function serializeArgs(args) {
+  return args.map((arg) => {
+    if (arg === null) return "null";
+    if (arg === void 0) return "undefined";
+    if (typeof arg === "object") {
+      try {
+        return JSON.stringify(arg, null, 2);
+      } catch {
+        return String(arg);
+      }
+    }
+    return String(arg);
+  }).join(" ");
+}
+function interceptConsole(level) {
+  console[level] = function(...args) {
+    originalConsole[level].apply(console, args);
+    if (window.self !== window.top && window.parent) {
+      try {
+        const message = serializeArgs(args);
+        const timestamp = (/* @__PURE__ */ new Date()).toLocaleTimeString();
+        window.parent.postMessage(
+          {
+            type: "console.forward",
+            data: {
+              timestamp,
+              level,
+              message
+            },
+            timestamp: Date.now()
+          },
+          "*"
+        );
+      } catch (error) {
+        originalConsole.error("[HaexHub] Failed to forward console message:", error);
+      }
+    }
+  };
+}
+function installConsoleForwarding(debug = false) {
+  if (typeof window === "undefined") {
+    return;
+  }
+  if (window.self === window.top) {
+    return;
+  }
+  if (!debug) {
+    console.log("[HaexHub] Console forwarding disabled (not in debug mode)");
+    return;
+  }
+  interceptConsole("log");
+  interceptConsole("info");
+  interceptConsole("warn");
+  interceptConsole("error");
+  interceptConsole("debug");
+  console.log("[HaexHub] Console forwarding installed");
+}
+var HaexVaultClient = class {
+  constructor(config = {}) {
+    this.pendingRequests = /* @__PURE__ */ new Map();
+    this.eventListeners = /* @__PURE__ */ new Map();
+    this.messageHandler = null;
+    this.initialized = false;
+    this.requestCounter = 0;
+    this._extensionInfo = null;
+    this._context = null;
+    this.reactiveSubscribers = /* @__PURE__ */ new Set();
+    this.isNativeWindow = false;
+    // Wird im Konstruktor initialisiert
+    this.setupPromise = null;
+    this.setupHook = null;
+    this._setupCompleted = false;
+    this.orm = null;
+    this.config = {
+      debug: config.debug ?? false,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      manifest: config.manifest
+    };
+    this.storage = new StorageAPI(this);
+    this.database = new DatabaseAPI(this);
+    this.filesystem = new FilesystemAPI(this);
+    this.web = new WebAPI(this);
+    this.permissions = new PermissionsAPI(this);
+    installConsoleForwarding(this.config.debug);
+    this.readyPromise = new Promise((resolve) => {
+      this.resolveReady = resolve;
+    });
+    this.init();
+  }
+  /**
+   * Gibt ein Promise zurück, das aufgelöst wird, sobald der Client
+   * initialisiert ist und Extension-Infos empfangen hat.
+   */
+  async ready() {
+    return this.readyPromise;
+  }
+  /**
+   * Gibt zurück, ob das Setup bereits abgeschlossen wurde.
+   */
+  get setupCompleted() {
+    return this._setupCompleted;
+  }
+  /**
+   * Registriert eine Setup-Funktion, die nach der Initialisierung ausgeführt wird.
+   * Diese Funktion sollte für Aufgaben wie Tabellenerstellung, Migrationen, etc. verwendet werden.
+   * @param setupFn Die Setup-Funktion, die ausgeführt werden soll
+   */
+  onSetup(setupFn) {
+    if (this.setupHook) {
+      throw new Error("Setup hook already registered");
+    }
+    this.setupHook = setupFn;
+  }
+  /**
+   * Gibt ein Promise zurück, das aufgelöst wird, sobald der Client vollständig eingerichtet ist.
+   * Dies umfasst die Initialisierung UND das Setup (z.B. Tabellenerstellung).
+   * Falls kein Setup-Hook registriert wurde, entspricht dies ready().
+   */
+  async setupComplete() {
+    await this.readyPromise;
+    if (!this.setupHook || this.setupCompleted) {
+      return;
+    }
+    if (!this.setupPromise) {
+      this.setupPromise = this.runSetupAsync();
+    }
+    return this.setupPromise;
+  }
+  async runSetupAsync() {
+    if (!this.setupHook) return;
+    try {
+      this.log("[HaexHub] Running setup hook...");
+      await this.setupHook();
+      this._setupCompleted = true;
+      this.log("[HaexHub] Setup completed successfully");
+      this.notifySubscribers();
+    } catch (error) {
+      this.log("[HaexHub] Setup failed:", error);
+      throw error;
+    }
+  }
+  /**
+   * Initialisiert die Drizzle-Datenbankinstanz.
+   * Muss nach der Definition des Schemas aufgerufen werden.
+   * @param schema Das Drizzle-Schemaobjekt (mit bereits geprefixten Tabellennamen).
+   * @returns Die typsichere Drizzle-Datenbankinstanz.
+   */
+  initializeDatabase(schema) {
+    if (!this._extensionInfo) {
+      throw new HaexHubError(
+        "EXTENSION_INFO_UNAVAILABLE" /* EXTENSION_INFO_UNAVAILABLE */,
+        "errors.client_not_ready"
+      );
+    }
+    const dbInstance = sqliteProxy.drizzle(
+      async (sql, params, method) => {
+        try {
+          if (method === "run" || method === "all") {
+            const result2 = await this.request(
+              HAEXTENSION_METHODS.database.execute,
+              {
+                query: sql,
+                params
+              }
+            );
+            if (method === "all") {
+              return { rows: result2.rows || [] };
+            }
+            if (result2.rows && Array.isArray(result2.rows) && result2.rows.length > 0) {
+              return { rows: result2.rows };
+            }
+            return result2;
+          }
+          const result = await this.request(HAEXTENSION_METHODS.database.query, {
+            query: sql,
+            params
+          });
+          const rows = result.rows;
+          if (method === "get") {
+            return { rows: rows.length > 0 ? rows.at(0) : void 0 };
+          }
+          return { rows };
+        } catch (error) {
+          this.log("Database operation failed:", error);
+          throw error;
+        }
+      },
+      {
+        schema,
+        logger: false
+      }
+    );
+    this.orm = dbInstance;
+    return dbInstance;
+  }
+  get extensionInfo() {
+    return this._extensionInfo;
+  }
+  get context() {
+    return this._context;
+  }
+  subscribe(callback) {
+    this.reactiveSubscribers.add(callback);
+    return () => {
+      this.reactiveSubscribers.delete(callback);
+    };
+  }
+  notifySubscribers() {
+    this.reactiveSubscribers.forEach((callback) => callback());
+  }
+  async getDependencies() {
+    return this.request("extensions.getDependencies");
+  }
+  getTableName(tableName) {
+    if (!this._extensionInfo) {
+      throw new HaexHubError(
+        "EXTENSION_INFO_UNAVAILABLE" /* EXTENSION_INFO_UNAVAILABLE */,
+        "errors.extension_info_unavailable"
+      );
+    }
+    this.validateTableName(tableName);
+    const { publicKey, name } = this._extensionInfo;
+    const extensionName = name;
+    return `"${publicKey}${TABLE_SEPARATOR}${extensionName}${TABLE_SEPARATOR}${tableName}"`;
+  }
+  getDependencyTableName(publicKey, extensionName, tableName) {
+    this.validatePublicKey(publicKey);
+    this.validateExtensionName(extensionName);
+    this.validateTableName(tableName);
+    return `"${publicKey}${TABLE_SEPARATOR}${extensionName}${TABLE_SEPARATOR}${tableName}"`;
+  }
+  parseTableName(fullTableName) {
+    let cleanTableName = fullTableName;
+    if (cleanTableName.startsWith('"') && cleanTableName.endsWith('"')) {
+      cleanTableName = cleanTableName.slice(1, -1);
+    }
+    const parts = cleanTableName.split(TABLE_SEPARATOR);
+    if (parts.length !== 3) {
+      return null;
+    }
+    const [publicKey, extensionName, tableName] = parts;
+    if (!publicKey || !extensionName || !tableName) {
+      return null;
+    }
+    return {
+      publicKey,
+      extensionName,
+      tableName
+    };
+  }
+  /**
+   * Execute a raw SQL query (SELECT)
+   * Returns rows as an array of objects
+   */
+  async query(sql, params = []) {
+    const result = await this.request(
+      HAEXTENSION_METHODS.database.query,
+      { query: sql, params }
+    );
+    if (this.config.debug) {
+      console.log("[SDK query()] Raw result:", JSON.stringify(result, null, 2));
+    }
+    return result.rows;
+  }
+  /**
+   * Alias for query() - more intuitive for SELECT statements
+   */
+  async select(sql, params = []) {
+    return this.query(sql, params);
+  }
+  /**
+   * Execute a raw SQL statement (INSERT, UPDATE, DELETE, CREATE, etc.)
+   * Returns rowsAffected and lastInsertId
+   */
+  async execute(sql, params = []) {
+    const result = await this.request(
+      HAEXTENSION_METHODS.database.execute,
+      { query: sql, params }
+    );
+    return {
+      rowsAffected: result.rowsAffected,
+      lastInsertId: result.lastInsertId
+    };
+  }
+  /**
+   * Registers extension migrations with HaexVault for CRDT synchronization
+   * HaexVault will validate and execute these migrations
+   * @param extensionVersion - The version of the extension
+   * @param migrations - Array of migration objects with name and SQL content
+   * @returns Promise that resolves when migrations are registered
+   */
+  async registerMigrationsAsync(extensionVersion, migrations) {
+    return this.database.registerMigrationsAsync(extensionVersion, migrations);
+  }
+  async requestDatabasePermission(request) {
+    return this.request("permissions.database.request", {
+      resource: request.resource,
+      operation: request.operation,
+      reason: request.reason
+    });
+  }
+  async checkDatabasePermission(resource, operation) {
+    const response = await this.request(
+      "permissions.database.check",
+      {
+        resource,
+        operation
+      }
+    );
+    return response.status === "granted";
+  }
+  async respondToSearch(requestId, results) {
+    await this.request("search.respond", {
+      requestId,
+      results
+    });
+  }
+  async request(method, params = {}) {
+    if (this.isNativeWindow && typeof window.__TAURI__ !== "undefined") {
+      return this.invoke(method, params);
+    }
+    return this.postMessage(method, params);
+  }
+  async postMessage(method, params) {
+    const requestId = this.generateRequestId();
+    const request = {
+      method,
+      params,
+      timestamp: Date.now()
+    };
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.pendingRequests.delete(requestId);
+        reject(
+          new HaexHubError("TIMEOUT" /* TIMEOUT */, "errors.timeout", {
+            timeout: this.config.timeout
+          })
+        );
+      }, this.config.timeout);
+      this.pendingRequests.set(requestId, { resolve, reject, timeout });
+      const targetOrigin = "*";
+      if (this.config.debug) {
+        console.log("[SDK Debug] ========== Sending Request ==========");
+        console.log("[SDK Debug] Request ID:", requestId);
+        console.log("[SDK Debug] Method:", request.method);
+        console.log("[SDK Debug] Params:", request.params);
+        console.log("[SDK Debug] Target origin:", targetOrigin);
+        console.log("[SDK Debug] Extension info:", this._extensionInfo);
+        console.log("[SDK Debug] ========================================");
+      }
+      window.parent.postMessage({ id: requestId, ...request }, targetOrigin);
+    });
+  }
+  async invoke(method, params) {
+    const { invoke } = window.__TAURI__.core;
+    if (this.config.debug) {
+      console.log("[SDK Debug] ========== Invoke Request ==========");
+      console.log("[SDK Debug] Method:", method);
+      console.log("[SDK Debug] Params:", params);
+      console.log("[SDK Debug] =======================================");
+    }
+    switch (method) {
+      case HAEXTENSION_METHODS.database.query:
+        return invoke("webview_extension_db_query", {
+          query: params.query,
+          params: params.params || []
+        });
+      case HAEXTENSION_METHODS.database.execute:
+        return invoke("webview_extension_db_execute", {
+          query: params.query,
+          params: params.params || []
+        });
+      case "permissions.web.check":
+        return invoke("webview_extension_check_web_permission", {
+          url: params.url
+        });
+      case "permissions.database.check":
+        return invoke("webview_extension_check_database_permission", {
+          resource: params.resource,
+          operation: params.operation
+        });
+      case "permissions.filesystem.check":
+        return invoke("webview_extension_check_filesystem_permission", {
+          path: params.path,
+          actionStr: params.action
+        });
+      case HAEXTENSION_METHODS.application.open:
+        return invoke("webview_extension_web_open", {
+          url: params.url
+        });
+      case HAEXTENSION_METHODS.web.fetch:
+        return invoke("webview_extension_web_request", {
+          url: params.url,
+          method: params.method,
+          headers: params.headers,
+          body: params.body
+        });
+      case HAEXTENSION_METHODS.filesystem.saveFile:
+        return invoke("webview_extension_fs_save_file", {
+          data: params.data,
+          defaultPath: params.defaultPath,
+          title: params.title,
+          filters: params.filters
+        });
+      case HAEXTENSION_METHODS.filesystem.openFile:
+        return invoke("webview_extension_fs_open_file", {
+          data: params.data,
+          fileName: params.fileName
+        });
+      default:
+        throw new HaexHubError(
+          "METHOD_NOT_FOUND" /* METHOD_NOT_FOUND */,
+          "errors.method_not_found",
+          { method }
+        );
+    }
+  }
+  on(eventType, callback) {
+    if (!this.eventListeners.has(eventType)) {
+      this.eventListeners.set(eventType, /* @__PURE__ */ new Set());
+    }
+    this.eventListeners.get(eventType).add(callback);
+  }
+  off(eventType, callback) {
+    const listeners = this.eventListeners.get(eventType);
+    if (listeners) {
+      listeners.delete(callback);
+    }
+  }
+  destroy() {
+    if (this.messageHandler) {
+      window.removeEventListener("message", this.messageHandler);
+    }
+    this.pendingRequests.forEach(({ timeout }) => clearTimeout(timeout));
+    this.pendingRequests.clear();
+    this.eventListeners.clear();
+    this.initialized = false;
+    this.log("HaexHub SDK destroyed");
+  }
+  async init() {
+    if (this.initialized) return;
+    const isInIframe = window.self !== window.top;
+    if (!isInIframe) {
+      try {
+        if (typeof window.__TAURI__ !== "undefined") {
+          const { invoke } = window.__TAURI__.core;
+          this._extensionInfo = await invoke("webview_extension_get_info");
+          this._context = await invoke("webview_extension_context_get");
+          this.isNativeWindow = true;
+          this.initialized = true;
+          this.log("HaexHub SDK initialized in native WebViewWindow mode");
+          this.log("Extension info:", this._extensionInfo);
+          this.log("Application context:", this._context);
+          this.notifySubscribers();
+          const { listen } = window.__TAURI__.event;
+          console.log("[HaexHub SDK] Setting up Tauri event listener for:", HAEXTENSION_EVENTS.CONTEXT_CHANGED);
+          try {
+            await listen(HAEXTENSION_EVENTS.CONTEXT_CHANGED, (event) => {
+              console.log("[HaexHub SDK] Received Tauri event:", HAEXTENSION_EVENTS.CONTEXT_CHANGED, event);
+              this.log("Received context change event:", event);
+              if (event.payload?.context) {
+                this._context = event.payload.context;
+                console.log("[HaexHub SDK] Updated context to:", this._context);
+                this.handleEvent({
+                  type: HAEXTENSION_EVENTS.CONTEXT_CHANGED,
+                  data: { context: this._context },
+                  timestamp: Date.now()
+                });
+              } else {
+                console.warn("[HaexHub SDK] Event received but no context in payload:", event);
+              }
+            });
+            console.log("[HaexHub SDK] Context change listener registered successfully");
+          } catch (error) {
+            console.error("[HaexHub SDK] Failed to setup context change listener:", error);
+            this.log("Failed to setup context change listener:", error);
+          }
+          this.resolveReady();
+          return;
+        }
+      } catch (error) {
+        this.log("Tauri commands failed, falling back to iframe mode", error);
+      }
+    }
+    if (window.self === window.top) {
+      throw new HaexHubError("NOT_IN_IFRAME" /* NOT_IN_IFRAME */, "errors.not_in_iframe");
+    }
+    this.messageHandler = this.handleMessage.bind(this);
+    window.addEventListener("message", this.messageHandler);
+    this.isNativeWindow = false;
+    this.initialized = true;
+    this.log("HaexHub SDK initialized in iframe mode");
+    try {
+      if (this.config.manifest) {
+        this._extensionInfo = {
+          publicKey: this.config.manifest.publicKey,
+          name: this.config.manifest.name,
+          version: this.config.manifest.version,
+          displayName: this.config.manifest.name
+        };
+        this.log("Extension info loaded from manifest:", this._extensionInfo);
+        this.notifySubscribers();
+      }
+      if (typeof window !== "undefined" && window.parent) {
+        const debugInfo = `SDK Debug:
+window.parent exists: ${!!window.parent}
+window.parent === window: ${window.parent === window}
+window.self === window.top: ${window.self === window.top}`;
+        try {
+          window.parent.postMessage({
+            type: "haexhub:debug",
+            data: debugInfo
+          }, "*");
+        } catch (e) {
+          alert(debugInfo + `
+postMessage error: ${e}`);
+        }
+      }
+      this._context = await this.request(HAEXTENSION_METHODS.context.get);
+      this.log("Application context received:", this._context);
+      this.notifySubscribers();
+      this.resolveReady();
+    } catch (error) {
+      this.log("Failed to load extension info or context:", error);
+      throw error;
+    }
+  }
+  handleMessage(event) {
+    if (this.config.debug) {
+      console.log("[SDK Debug] ========== Message Received ==========");
+      console.log("[SDK Debug] Event origin:", event.origin);
+      console.log(
+        "[SDK Debug] Event source:",
+        event.source === window.parent ? "parent window" : "unknown"
+      );
+      console.log("[SDK Debug] Event data:", event.data);
+      console.log("[SDK Debug] Extension info loaded:", !!this._extensionInfo);
+      console.log(
+        "[SDK Debug] Pending requests count:",
+        this.pendingRequests.size
+      );
+    }
+    if (event.source !== window.parent) {
+      if (this.config.debug) {
+        console.error("[SDK Debug] \u274C REJECTED: Message not from parent window!");
+      }
+      return;
+    }
+    const data = event.data;
+    if ("id" in data && this.pendingRequests.has(data.id)) {
+      if (this.config.debug) {
+        console.log("[SDK Debug] \u2705 Found pending request for ID:", data.id);
+      }
+      const pending = this.pendingRequests.get(data.id);
+      clearTimeout(pending.timeout);
+      this.pendingRequests.delete(data.id);
+      if (data.error) {
+        if (this.config.debug) {
+          console.error("[SDK Debug] \u274C Request failed:", data.error);
+        }
+        pending.reject(data.error);
+      } else {
+        if (this.config.debug) {
+          console.log("[SDK Debug] \u2705 Request succeeded:", data.result);
+        }
+        pending.resolve(data.result);
+      }
+      return;
+    }
+    if ("id" in data && !this.pendingRequests.has(data.id)) {
+      if (this.config.debug) {
+        console.warn(
+          "[SDK Debug] \u26A0\uFE0F Received response for unknown request ID:",
+          data.id
+        );
+        console.warn(
+          "[SDK Debug] Known IDs:",
+          Array.from(this.pendingRequests.keys())
+        );
+      }
+    }
+    if ("type" in data && data.type) {
+      if (this.config.debug) {
+        console.log("[SDK Debug] Event received:", data.type);
+      }
+      this.handleEvent(data);
+    }
+    if (this.config.debug) {
+      console.log("[SDK Debug] ========== End Message ==========");
+    }
+  }
+  handleEvent(event) {
+    if (event.type === HAEXTENSION_EVENTS.CONTEXT_CHANGED) {
+      const contextEvent = event;
+      this._context = contextEvent.data.context;
+      this.log("Context updated:", this._context);
+      this.notifySubscribers();
+    }
+    this.emitEvent(event);
+  }
+  emitEvent(event) {
+    this.log("Event received:", event);
+    const listeners = this.eventListeners.get(event.type);
+    if (listeners) {
+      listeners.forEach((callback) => callback(event));
+    }
+  }
+  generateRequestId() {
+    return `req_${++this.requestCounter}`;
+  }
+  validatePublicKey(publicKey) {
+    if (!publicKey || typeof publicKey !== "string" || publicKey.trim() === "") {
+      throw new HaexHubError(
+        "INVALID_PUBLIC_KEY" /* INVALID_PUBLIC_KEY */,
+        "errors.invalid_public_key",
+        { publicKey }
+      );
+    }
+  }
+  validateExtensionName(extensionName) {
+    if (!extensionName || !/^[a-z][a-z0-9-]*$/i.test(extensionName)) {
+      throw new HaexHubError(
+        "INVALID_EXTENSION_NAME" /* INVALID_EXTENSION_NAME */,
+        "errors.invalid_extension_name",
+        { extensionName }
+      );
+    }
+    if (extensionName.includes(TABLE_SEPARATOR)) {
+      throw new HaexHubError(
+        "INVALID_EXTENSION_NAME" /* INVALID_EXTENSION_NAME */,
+        "errors.extension_name_contains_separator",
+        { extensionName, separator: TABLE_SEPARATOR }
+      );
+    }
+  }
+  validateTableName(tableName) {
+    if (!tableName || typeof tableName !== "string") {
+      throw new HaexHubError(
+        "INVALID_TABLE_NAME" /* INVALID_TABLE_NAME */,
+        "errors.table_name_empty"
+      );
+    }
+    if (tableName.includes(TABLE_SEPARATOR)) {
+      throw new HaexHubError(
+        "INVALID_TABLE_NAME" /* INVALID_TABLE_NAME */,
+        "errors.table_name_contains_separator",
+        { tableName, separator: TABLE_SEPARATOR }
+      );
+    }
+    if (!/^[a-z][a-z0-9-_]*$/i.test(tableName)) {
+      throw new HaexHubError(
+        "INVALID_TABLE_NAME" /* INVALID_TABLE_NAME */,
+        "errors.table_name_format",
+        { tableName }
+      );
+    }
+  }
+  log(...args) {
+    if (this.config.debug) {
+      console.log("[HaexHub SDK]", ...args);
+    }
+  }
+};
+
+// src/runtime/nuxt.plugin.client.ts
+var nuxt_plugin_client_default = app.defineNuxtPlugin(async (nuxtApp) => {
+  const manifest = nuxtApp.$config.public.haexhubManifest;
+  const client = new HaexVaultClient({
+    // @ts-ignore
+    debug: nuxtApp.payload.config.public.debug ?? false,
+    manifest: manifest || void 0
+  });
+  const state = vue.shallowRef({
+    isReady: false,
+    isSetupComplete: false,
+    context: client.context
+  });
+  await client.ready();
+  console.log("[Nuxt Plugin] Client ready, context:", client.context);
+  state.value = {
+    isReady: true,
+    isSetupComplete: false,
+    context: client.context
+  };
+  console.log("[Nuxt Plugin] Initial state set:", state.value);
+  client.subscribe(() => {
+    console.log("[Nuxt Plugin] Client context updated:", client.context);
+    const isSetupComplete = client.setupCompleted;
+    state.value = {
+      ...state.value,
+      context: client.context,
+      isSetupComplete
+    };
+    console.log("[Nuxt Plugin] State updated:", state.value);
+  });
+  const haexhubPlugin = {
+    client,
+    // Der rohe Client (für client.orm, client.database, etc.)
+    state
+    // Der reaktive State (für die UI)
+  };
+  return {
+    provide: {
+      haexhub: haexhubPlugin
+    }
+  };
+});
+
+module.exports = nuxt_plugin_client_default;
+//# sourceMappingURL=nuxt.plugin.client.js.map
+//# sourceMappingURL=nuxt.plugin.client.js.map