@konemono/nostr-login 1.7.59 → 1.7.61

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@konemono/nostr-login",
-  "version": "1.7.59",
+  "version": "1.7.61",
   "description": "",
   "main": "./dist/index.esm.js",
   "types": "./dist/index.d.ts",

package/src/modules/AmberDirectSigner.ts

@@ -1,5 +1,7 @@
 import { Signer } from './Nostr';
 
+const PENDING_KEY = 'amber_pending_request';
+
 export class AmberDirectSigner implements Signer {
   private _pubkey: string = '';
   private static pendingResolves: Map<string, (result: any) => void> = new Map();
@@ -49,31 +51,36 @@ export class AmberDirectSigner implements Signer {
 
   private setPending(id: string, content: string, type: string) {
     const hash = this.getHash(content);
-    sessionStorage.setItem(`amber_pending_${id}`, JSON.stringify({ hash, type }));
+    const data = JSON.stringify({ id, type, hash, timestamp: Date.now() });
+    sessionStorage.setItem(`amber_pending_${id}`, data);
+    localStorage.setItem(PENDING_KEY, data); // Backup for reloads
   }
 
   public static resolvePending(id: string, type: string, result: string) {
-    // Try resolving by ID first
+    console.log('AmberDirectSigner: resolvePending', { id, type, pendingCount: this.pendingResolves.size });
+
     let resolve = this.pendingResolves.get(id);
     
-    // Fallback: If no ID match, try resolving by type if only one is pending of that type
+    // Fallback by type if only one pending of that type
     if (!resolve) {
-        console.log('No direct ID match for Amber resolve, searching by type', { id, type });
+        console.log('AmberDirectSigner: Falling back to resolve by type', type);
         for (const [pendingId, pendingResolve] of this.pendingResolves.entries()) {
-            const pending = sessionStorage.getItem(`amber_pending_${pendingId}`);
+            const pending = sessionStorage.getItem(`amber_pending_${pendingId}`) || localStorage.getItem(PENDING_KEY);
             if (pending) {
-                const { type: pendingType } = JSON.parse(pending);
-                if (pendingType === type) {
-                    resolve = pendingResolve;
-                    id = pendingId;
-                    break;
-                }
+                try {
+                    const { type: pendingType } = JSON.parse(pending);
+                    if (pendingType === type || type.startsWith(pendingType)) {
+                        resolve = pendingResolve;
+                        id = pendingId;
+                        break;
+                    }
+                } catch (e) {}
             }
         }
     }
 
     if (resolve) {
-        console.log('Resolving pending Amber promise', { id, type });
+        console.log('AmberDirectSigner: Promise resolved', id);
         resolve(result);
         this.pendingResolves.delete(id);
         return true;
@@ -84,9 +91,7 @@ export class AmberDirectSigner implements Signer {
   async signEvent(event: any): Promise<any> {
     const content = JSON.stringify(event);
     const cached = this.checkCache(content, 'sign_event');
-    if (cached) {
-        return JSON.parse(cached);
-    }
+    if (cached) return JSON.parse(cached);
 
     const id = Math.random().toString(36).substring(7);
     this.setPending(id, content, 'sign_event');
@@ -99,6 +104,7 @@ export class AmberDirectSigner implements Signer {
 
   async getPublicKey(): Promise<string> {
     const id = Math.random().toString(36).substring(7);
+    this.setPending(id, '', 'get_public_key');
     const url = this.generateUrl('', 'get_public_key', id);
     window.location.href = url;
     return new Promise((resolve) => {
@@ -161,36 +167,28 @@ export class AmberDirectSigner implements Signer {
   private generateUrl(content: string, type: string, id: string, recipient?: string): string {
     const callbackUrl = new URL(window.location.origin + window.location.pathname);
     
-    // Preserve other relevant current URL params if necessary, but avoid amber internal ones
-    const currentParams = new URLSearchParams(window.location.search);
-    currentParams.forEach((value, key) => {
-        if (!['amberType', 'amberId', 'signature', 'result', 'pubKey', 'pubkey'].includes(key)) {
-            callbackUrl.searchParams.set(key, value);
-        }
-    });
-
+    // Minimal parameters in callbackUrl to avoid conflicts
     callbackUrl.searchParams.set('amberType', type);
     callbackUrl.searchParams.set('amberId', id);
 
     const name = document.title || window.location.hostname || 'Nostr Login';
 
-    const params = new URLSearchParams();
-    params.set('type', type);
-    params.set('id', id);
-    params.set('callbackUrl', callbackUrl.toString());
-    params.set('name', name);
-    params.set('app_name', name); // Alias just in case
+    const params: string[] = [];
+    params.push(`type=${encodeURIComponent(type)}`);
+    params.push(`id=${encodeURIComponent(id)}`);
+    params.push(`callbackUrl=${encodeURIComponent(callbackUrl.toString())}`);
+    params.push(`name=${encodeURIComponent(name)}`);
+    params.push(`app_name=${encodeURIComponent(name)}`);
 
     if (recipient) {
-        params.set('pubkey', recipient);
-        params.set('pubKey', recipient); // Alias
+        params.push(`pubkey=${encodeURIComponent(recipient)}`);
     } else if (this._pubkey) {
-        params.set('pubkey', this._pubkey);
-        params.set('pubKey', this._pubkey); // Alias
+        params.push(`pubkey=${encodeURIComponent(this._pubkey)}`);
     }
 
-    const dataPart = content ? encodeURIComponent(content) : '/';
-    return `nostrsigner:${dataPart}?${params.toString()}`;
+    const dataPart = content ? encodeURIComponent(content) : 'get_public_key';
+    // Use nostrsigner: scheme as primary which is standard NIP-55
+    return `nostrsigner:${dataPart}?${params.join('&')}`;
   }
 
   public static parseResponse(): { type: string; id: string; result: string } | null {
@@ -200,12 +198,31 @@ export class AmberDirectSigner implements Signer {
 
     const getParam = (name: string) => params.get(name) || hashParams.get(name);
 
-    const type = getParam('amberType') || getParam('type');
-    const id = getParam('amberId') || getParam('id');
+    let type = getParam('amberType') || getParam('type');
+    let id = getParam('amberId') || getParam('id');
     const result = getParam('signature') || getParam('result') || getParam('pubKey') || getParam('pubkey');
 
+    // Fallback to localStorage pending if params are missing/merged
+    if (result && (!type || !id)) {
+        const pending = localStorage.getItem(PENDING_KEY);
+        if (pending) {
+            try {
+                const { id: pId, type: pType } = JSON.parse(pending);
+                if (!type) type = pType;
+                if (!id) id = pId;
+                console.log('AmberDirectSigner: Recovered type/id from localStorage');
+            } catch (e) {}
+        }
+    }
+
     if (type && result) {
-        // ID might be missing in some older redirect cases, but we need it for precise resolution
+        // Handle "ID stuck to type" or typo cases
+        let finalType = type.toLowerCase();
+        if (finalType.includes('get_pub')) finalType = 'get_public_key';
+        else if (finalType.includes('sign_event')) finalType = 'sign_event';
+        else if (finalType.includes('encrypt')) finalType = finalType.includes('44') ? 'nip44_encrypt' : 'nip04_encrypt';
+        else if (finalType.includes('decrypt')) finalType = finalType.includes('44') ? 'nip44_decrypt' : 'nip04_decrypt';
+
         const finalId = id || '';
 
         // Clean up URL
@@ -215,8 +232,10 @@ export class AmberDirectSigner implements Signer {
         });
         newUrl.hash = ''; 
         window.history.replaceState({}, '', newUrl.toString());
+        
+        localStorage.removeItem(PENDING_KEY); // Done
 
-        return { type, id: finalId, result };
+        return { type: finalType, id: finalId, result };
     }
     return null;
   }

package/src/modules/AuthNostrService.ts

@@ -88,10 +88,19 @@ class AuthNostrService extends EventEmitter implements Signer {
 
     setTimeout(() => this.checkAmberResponse(), 100);
 
-    window.addEventListener('focus', () => {
-      console.log('Window focused, checking Amber response');
+    const check = () => {
       this.checkAmberResponse();
+    };
+
+    window.addEventListener('focus', check);
+    window.addEventListener('visibilitychange', () => {
+        if (document.visibilityState === 'visible') check();
     });
+    window.addEventListener('popstate', check);
+    window.addEventListener('hashchange', check);
+
+    // Periodic check as a safety net
+    setInterval(check, 1000);
   }
 
   private checkAmberResponse() {
@@ -99,10 +108,16 @@ class AuthNostrService extends EventEmitter implements Signer {
     if (response) {
       console.log('Amber response detected', response);
 
+      // Stop the "Connecting..." spinner
+      this.emit('onAuthUrl', { url: '' });
+
       // Resolve pending promises if any (for non-reload cases)
-      AmberDirectSigner.resolvePending(response.id, response.type, response.result);
+      const resolved = AmberDirectSigner.resolvePending(response.id, response.type, response.result);
+      if (resolved) {
+          console.log('Resolved pending Amber promise via resolvePending');
+      }
 
-      if (response.type === 'get_public_key') {
+      if (response.type === 'get_public_key' || response.type.includes('pub')) {
         const info: Info = {
           pubkey: response.result,
           authMethod: 'amber' as any,
@@ -181,6 +196,8 @@ class AuthNostrService extends EventEmitter implements Signer {
     if (link && !iframeUrl) {
       if (link === 'amber') {
         const signer = new AmberDirectSigner();
+        const url = (signer as any).generateUrl('', 'get_public_key', Math.random().toString(36).substring(7));
+        this.emit('onAuthUrl', { url });
         return (signer as any).getPublicKey(); // will redirect
       }
       window.open(link, '_blank', 'width=400,height=700');