@haex-space/vault-sdk 2.3.8 → 2.3.10

package/dist/vue.mjs

@@ -335,7 +335,9 @@ var HAEXTENSION_EVENTS = {
   /** Context (theme, locale, platform) has changed */
   CONTEXT_CHANGED: "haextension:context:changed",
   /** Search request from HaexHub */
-  SEARCH_REQUEST: "haextension:search:request"
+  SEARCH_REQUEST: "haextension:search:request",
+  /** External request from authorized client (browser extension, CLI, server, etc.) */
+  EXTERNAL_REQUEST: "haextension:external:request"
 };
 
 // src/methods.ts
@@ -755,6 +757,7 @@ var HaexVaultClient = class {
   constructor(config = {}) {
     this.pendingRequests = /* @__PURE__ */ new Map();
     this.eventListeners = /* @__PURE__ */ new Map();
+    this.externalRequestHandlers = /* @__PURE__ */ new Map();
     this.messageHandler = null;
     this.initialized = false;
     this.requestCounter = 0;
@@ -1017,6 +1020,40 @@ var HaexVaultClient = class {
       results
     });
   }
+  /**
+   * Register a handler for external requests (from browser extensions, CLI, servers, etc.)
+   *
+   * @param action - The action/method name to handle (e.g., "get-logins", "get-totp")
+   * @param handler - Function that processes the request and returns a response
+   * @returns Unsubscribe function to remove the handler
+   *
+   * @example
+   * ```typescript
+   * client.onExternalRequest("get-logins", async (request) => {
+   *   const entries = await getMatchingEntries(request.payload.url);
+   *   return {
+   *     requestId: request.requestId,
+   *     success: true,
+   *     data: { entries }
+   *   };
+   * });
+   * ```
+   */
+  onExternalRequest(action, handler) {
+    this.externalRequestHandlers.set(action, handler);
+    this.log(`[ExternalRequest] Registered handler for action: ${action}`);
+    return () => {
+      this.externalRequestHandlers.delete(action);
+      this.log(`[ExternalRequest] Unregistered handler for action: ${action}`);
+    };
+  }
+  /**
+   * Send a response to an external request back to haex-vault
+   * This is called internally after a handler processes a request
+   */
+  async respondToExternalRequest(response) {
+    await this.request("external.respond", response);
+  }
   async request(method, params = {}) {
     if (this.isNativeWindow && typeof window.__TAURI__ !== "undefined") {
       return this.invoke(method, params);
@@ -1114,6 +1151,13 @@ var HaexVaultClient = class {
           extensionVersion: params.extensionVersion,
           migrations: params.migrations
         });
+      case "external.respond":
+        return invoke("webview_extension_external_respond", {
+          requestId: params.requestId,
+          success: params.success,
+          data: params.data,
+          error: params.error
+        });
       default:
         throw new HaexHubError(
           "METHOD_NOT_FOUND" /* METHOD_NOT_FOUND */,
@@ -1182,6 +1226,22 @@ var HaexVaultClient = class {
             console.error("[HaexSpace SDK] Failed to setup context change listener:", error);
             this.log("Failed to setup context change listener:", error);
           }
+          try {
+            await listen(HAEXTENSION_EVENTS.EXTERNAL_REQUEST, (event) => {
+              this.log("Received external request event:", event);
+              if (event.payload) {
+                this.handleEvent({
+                  type: HAEXTENSION_EVENTS.EXTERNAL_REQUEST,
+                  data: event.payload,
+                  timestamp: Date.now()
+                });
+              }
+            });
+            console.log("[HaexSpace SDK] External request listener registered successfully");
+          } catch (error) {
+            console.error("[HaexSpace SDK] Failed to setup external request listener:", error);
+            this.log("Failed to setup external request listener:", error);
+          }
           this.resolveReady();
           return;
         }
@@ -1303,8 +1363,38 @@ postMessage error: ${e}`);
       this.log("Context updated:", this._context);
       this.notifySubscribers();
     }
+    if (event.type === HAEXTENSION_EVENTS.EXTERNAL_REQUEST) {
+      const externalEvent = event;
+      this.handleExternalRequest(externalEvent.data);
+      return;
+    }
     this.emitEvent(event);
   }
+  async handleExternalRequest(request) {
+    this.log(`[ExternalRequest] Received request: ${request.action} from ${request.publicKey.substring(0, 20)}...`);
+    const handler = this.externalRequestHandlers.get(request.action);
+    if (!handler) {
+      this.log(`[ExternalRequest] No handler for action: ${request.action}`);
+      await this.respondToExternalRequest({
+        requestId: request.requestId,
+        success: false,
+        error: `No handler registered for action: ${request.action}`
+      });
+      return;
+    }
+    try {
+      const response = await handler(request);
+      await this.respondToExternalRequest(response);
+      this.log(`[ExternalRequest] Response sent for: ${request.action}`);
+    } catch (error) {
+      this.log(`[ExternalRequest] Handler error:`, error);
+      await this.respondToExternalRequest({
+        requestId: request.requestId,
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
   emitEvent(event) {
     this.log("Event received:", event);
     const listeners = this.eventListeners.get(event.type);