@konemono/nostr-login 1.7.29 → 1.7.31

package/package.json

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

package/src/modules/AuthNostrService.ts

@@ -572,7 +572,8 @@ class AuthNostrService extends EventEmitter implements Signer {
     }
   }
 
-  public async signEvent(event: any) {
+  public async signEvent(ev: any) {
+    const event = { ...ev };
     if (this.localSigner) {
       event.pubkey = getPublicKey(this.localSigner.privateKey!);
       event.id = getEventHash(event);

package/src/modules/Nip46.ts

@@ -1,173 +1,579 @@
-// Nip46.ts
-import NDK, { NDKEvent, NDKFilter, NDKNip46Signer, NDKNostrRpc, NDKRpcRequest, NDKRpcResponse, NDKSubscription, NostrEvent } from '@nostr-dev-kit/ndk';
+import NDK, { NDKEvent, NDKFilter, NDKNip46Signer, NDKNostrRpc, NDKRpcRequest, NDKRpcResponse, NDKSubscription, NDKSubscriptionCacheUsage, NostrEvent } from '@nostr-dev-kit/ndk';
 import { validateEvent, verifySignature } from 'nostr-tools';
 import { PrivateKeySigner } from './Signer';
 import { NIP46_TIMEOUT } from '../const';
 import ProcessManager from './ProcessManager';
 
-/* =========================
- * NostrRpc
- * ========================= */
 class NostrRpc extends NDKNostrRpc {
-  protected processManager: ProcessManager;
+  protected processManager?: ProcessManager;
   protected _ndk: NDK;
   protected _signer: PrivateKeySigner;
   protected requests: Set<string> = new Set();
   protected requestTimeouts: Map<string, NodeJS.Timeout> = new Map();
   private sub?: NDKSubscription;
-  protected _useNip44 = false;
+  protected _useNip44: boolean = false;
 
-  constructor(ndk: NDK, signer: PrivateKeySigner, processManager: ProcessManager) {
+  public constructor(ndk: NDK, signer: PrivateKeySigner, processManager?: ProcessManager) {
     super(ndk, signer, ndk.debug.extend('nip46:signer:rpc'));
     this._ndk = ndk;
     this._signer = signer;
     this.processManager = processManager;
   }
 
-  async subscribe(filter: NDKFilter): Promise<NDKSubscription> {
+  public async subscribe(filter: NDKFilter): Promise<NDKSubscription> {
     filter.kinds = filter.kinds?.filter(k => k === 24133);
     this.sub = await super.subscribe(filter);
     return this.sub;
   }
 
-  stop() {
-    for (const t of this.requestTimeouts.values()) clearTimeout(t);
-    this.requestTimeouts.clear();
+  public stop() {
+    this.clearAllTimeouts();
     if (this.sub) {
       this.sub.stop();
       this.sub = undefined;
     }
   }
 
+  private clearAllTimeouts() {
+    for (const timeout of this.requestTimeouts.values()) {
+      clearTimeout(timeout);
+    }
+    this.requestTimeouts.clear();
+  }
+
   protected clearTimeout(id: string) {
-    const t = this.requestTimeouts.get(id);
-    if (t) clearTimeout(t);
-    this.requestTimeouts.delete(id);
+    const timeout = this.requestTimeouts.get(id);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.requestTimeouts.delete(id);
+    }
   }
 
-  setUseNip44(v: boolean) {
-    this._useNip44 = v;
+  public setUseNip44(useNip44: boolean) {
+    this._useNip44 = useNip44;
   }
 
-  async parseEvent(event: NDKEvent): Promise<NDKRpcRequest | NDKRpcResponse> {
+  private isNip04(ciphertext: string) {
+    const l = ciphertext.length;
+    if (l < 28) return false;
+    return ciphertext[l - 28] === '?' && ciphertext[l - 27] === 'i' && ciphertext[l - 26] === 'v' && ciphertext[l - 25] === '=';
+  }
+
+  public async parseEvent(event: NDKEvent): Promise<NDKRpcRequest | NDKRpcResponse> {
     const remoteUser = this._ndk.getUser({ pubkey: event.pubkey });
     remoteUser.ndk = this._ndk;
+    const decrypt = this.isNip04(event.content) ? this._signer.decrypt : this._signer.decryptNip44;
+    const decryptedContent = await decrypt.call(this._signer, remoteUser, event.content);
+    const parsedContent = JSON.parse(decryptedContent);
+    const { id, method, params, result, error } = parsedContent;
+
+    if (method) {
+      return { id, pubkey: event.pubkey, method, params, event };
+    } else {
+      return { id, result, error, event };
+    }
+  }
 
-    const decrypted = await this._signer.decrypt.call(this._signer, remoteUser, event.content);
+  public async parseNostrConnectReply(reply: any, secret: string) {
+    const event = new NDKEvent(this._ndk, reply);
+    const parsedEvent = await this.parseEvent(event);
+    console.log('nostr connect parsedEvent', parsedEvent);
+    if (!(parsedEvent as NDKRpcRequest).method) {
+      const response = parsedEvent as NDKRpcResponse;
+      if (response.result !== secret) throw new Error(response.error);
+      return event.pubkey;
+    } else {
+      throw new Error('Bad nostr connect reply');
+    }
+  }
 
-    const { id, method, params, result, error } = JSON.parse(decrypted);
+  public async listen(nostrConnectSecret: string): Promise<string> {
+    const pubkey = this._signer.pubkey;
+    console.log('nostr-login listening for conn to', pubkey);
+    const sub = await this.subscribe({
+      'kinds': [24133],
+      '#p': [pubkey],
+    });
+    return new Promise<string>((ok, err) => {
+      const timeoutId = setTimeout(() => {
+        this.stop();
+        err(new Error('NIP46 listen timeout'));
+      }, NIP46_TIMEOUT);
+
+      sub.on('event', async (event: NDKEvent) => {
+        try {
+          const parsedEvent = await this.parseEvent(event);
+          if (!(parsedEvent as NDKRpcRequest).method) {
+            const response = parsedEvent as NDKRpcResponse;
+
+            if (response.result === 'auth_url') return;
+
+            if (response.result === 'ack' || response.result === nostrConnectSecret) {
+              clearTimeout(timeoutId);
+              ok(event.pubkey);
+            } else {
+              clearTimeout(timeoutId);
+              err(response.error);
+            }
+          }
+        } catch (e) {
+          console.log('error parsing event', e, event.rawEvent());
+        }
+        this.stop();
+      });
+    });
+  }
 
-    return method ? { id, pubkey: event.pubkey, method, params, event } : { id, result, error, event };
+  public async connect(pubkey: string, token?: string, perms?: string) {
+    return new Promise<void>((ok, err) => {
+      const connectParams = [pubkey!, token || '', perms || ''];
+
+      const timeoutId = setTimeout(() => {
+        err(new Error('NIP46 connect timeout'));
+      }, NIP46_TIMEOUT);
+
+      this.sendRequest(pubkey!, 'connect', connectParams, 24133, (response: NDKRpcResponse) => {
+        clearTimeout(timeoutId);
+        if (response.result === 'ack') {
+          ok();
+        } else {
+          err(response.error);
+        }
+      });
+    });
   }
 
-  protected getId() {
-    return Math.random().toString(36).slice(2);
+  protected getId(): string {
+    return Math.random().toString(36).substring(7);
   }
 
-  protected async ensureConnected() {
+  protected async ensureConnected(): Promise<void> {
     const relays = Array.from(this._ndk.pool.relays.values());
-    if (relays.some(r => r.status === 1)) return;
+    console.log(
+      'Checking relay connections:',
+      relays.map(r => ({ url: r.url, status: r.status })),
+    );
+
+    const connectedRelays = relays.filter(r => r.status === 1);
+
+    if (connectedRelays.length === 0) {
+      console.log('No connected relays, forcing reconnection...');
+
+      // 既存の接続を全てクリーンアップ
+      for (const relay of relays) {
+        try {
+          await relay.disconnect();
+        } catch (e) {
+          console.log('Error disconnecting relay:', relay.url, e);
+        }
+      }
 
-    for (const r of relays) {
-      try {
-        await r.disconnect();
-      } catch {}
+      // 再接続
+      await this._ndk.connect();
+
+      // 接続確立を待つ
+      await new Promise<void>((resolve, reject) => {
+        const timeout = setTimeout(() => {
+          const status = Array.from(this._ndk.pool.relays.values()).map(r => ({ url: r.url, status: r.status }));
+          console.error('Failed to reconnect to relays within 10s. Status:', status);
+          reject(new Error('Failed to reconnect to relays'));
+        }, 10000);
+
+        const checkConnection = () => {
+          const connected = Array.from(this._ndk.pool.relays.values()).filter(r => r.status === 1);
+          if (connected.length > 0) {
+            clearTimeout(timeout);
+            console.log(
+              'Successfully reconnected to',
+              connected.length,
+              'relays:',
+              connected.map(r => r.url),
+            );
+            resolve();
+          } else {
+            setTimeout(checkConnection, 200);
+          }
+        };
+        checkConnection();
+      });
+    } else {
+      console.log(
+        'Already connected to',
+        connectedRelays.length,
+        'relays:',
+        connectedRelays.map(r => r.url),
+      );
     }
-
-    await this._ndk.connect();
   }
 
-  async sendRequest(remotePubkey: string, method: string, params: string[] = [], kind = 24133, cb?: (r: NDKRpcResponse) => void): Promise<NDKRpcResponse> {
-    this.processManager.pause();
+  public async sendRequest(remotePubkey: string, method: string, params: string[] = [], kind = 24133, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse> {
+    console.log('sendRequest called:', method, 'to', remotePubkey);
+
     try {
+      this.processManager?.pause();
       await this.ensureConnected();
+    } catch (e) {
+      console.error('Failed to ensure connection:', e);
+      if (cb) {
+        cb({
+          id: '',
+          result: '',
+          error: 'Failed to connect to relays: ' + (e as Error).message,
+          event: undefined as any,
+        });
+      }
+      throw e;
     } finally {
-      this.processManager.resume();
+      this.processManager?.resume();
     }
 
     const id = this.getId();
+
     this.setResponseHandler(id, cb);
 
     const event = await this.createRequestEvent(id, remotePubkey, method, params, kind);
-    await event.publish();
+    console.log('sendRequest event created', { event, method, remotePubkey, params });
+
+    try {
+      await event.publish();
+      console.log('sendRequest event published successfully');
+    } catch (e) {
+      console.error('Failed to publish event:', e);
+      this.clearTimeout(id);
+      this.requests.delete(id);
+      if (cb) {
+        cb({
+          id,
+          result: '',
+          error: 'Failed to publish event: ' + (e as Error).message,
+          event: undefined as any,
+        });
+      }
+      throw e;
+    }
 
     // @ts-ignore
-    return undefined;
+    return undefined as NDKRpcResponse;
   }
 
-  protected setResponseHandler(id: string, cb?: (r: NDKRpcResponse) => void) {
-    const to = setTimeout(() => {
-      this.requests.delete(id);
-      cb?.({ id, result: '', error: 'timeout', event: undefined as any });
+  protected setResponseHandler(id: string, cb?: (res: NDKRpcResponse) => void) {
+    let authUrlSent = false;
+    const now = Date.now();
+
+    const timeoutId = setTimeout(() => {
+      if (this.requests.has(id)) {
+        this.requests.delete(id);
+        this.requestTimeouts.delete(id);
+        console.log('NIP46 request timeout for', id);
+        if (cb) {
+          cb({
+            id,
+            result: '',
+            error: 'NIP46 request timeout',
+            event: undefined as any,
+          });
+        }
+      }
     }, NIP46_TIMEOUT);
 
-    this.requestTimeouts.set(id, to);
-
-    this.once(`response-${id}`, r => {
-      this.clearTimeout(id);
-      this.requests.delete(id);
-      cb?.(r);
+    this.requestTimeouts.set(id, timeoutId);
+
+    return new Promise<NDKRpcResponse>(() => {
+      const responseHandler = (response: NDKRpcResponse) => {
+        if (response.result === 'auth_url') {
+          this.once(`response-${id}`, responseHandler);
+          if (!authUrlSent) {
+            authUrlSent = true;
+            this.emit('authUrl', response.error);
+          }
+        } else if (cb) {
+          if (this.requests.has(id)) {
+            this.clearTimeout(id);
+            this.requests.delete(id);
+            console.log('nostr-login processed nip46 request in', Date.now() - now, 'ms');
+            cb(response);
+          }
+        }
+      };
+
+      this.once(`response-${id}`, responseHandler);
     });
   }
 
-  protected async createRequestEvent(id: string, remotePubkey: string, method: string, params: string[], kind: number) {
+  protected async createRequestEvent(id: string, remotePubkey: string, method: string, params: string[] = [], kind = 24133) {
     this.requests.add(id);
     const localUser = await this._signer.user();
     const remoteUser = this._ndk.getUser({ pubkey: remotePubkey });
+    const request = { id, method, params };
 
     const event = new NDKEvent(this._ndk, {
       kind,
-      content: JSON.stringify({ id, method, params }),
+      content: JSON.stringify(request),
       tags: [['p', remotePubkey]],
       pubkey: localUser.pubkey,
     } as NostrEvent);
 
-    event.content = await this._signer.encrypt.call(this._signer, remoteUser, event.content);
-
+    const useNip44 = this._useNip44 && method !== 'create_account';
+    const encrypt = useNip44 ? this._signer.encryptNip44 : this._signer.encrypt;
+    event.content = await encrypt.call(this._signer, remoteUser, event.content);
     await event.sign(this._signer);
+
     return event;
   }
 }
 
-/* =========================
- * IframeNostrRpc
- * ========================= */
 export class IframeNostrRpc extends NostrRpc {
+  private peerOrigin?: string;
   private iframePort?: MessagePort;
+  private iframeRequests = new Map<string, { id: string; pubkey: string }>();
+
+  public constructor(ndk: NDK, localSigner: PrivateKeySigner, iframePeerOrigin?: string) {
+    super(ndk, localSigner);
+    this._ndk = ndk;
+    this.peerOrigin = iframePeerOrigin;
+  }
 
-  constructor(ndk: NDK, signer: PrivateKeySigner, processManager: ProcessManager) {
-    super(ndk, signer, processManager);
+  public async subscribe(filter: NDKFilter): Promise<NDKSubscription> {
+    if (!this.peerOrigin) return super.subscribe(filter);
+    return new NDKSubscription(
+      this._ndk,
+      {},
+      {
+        closeOnEose: true,
+        cacheUsage: NDKSubscriptionCacheUsage.ONLY_CACHE,
+      },
+    );
   }
 
-  setWorkerIframePort(port: MessagePort) {
+  public setWorkerIframePort(port: MessagePort) {
+    if (!this.peerOrigin) throw new Error('Unexpected iframe port');
+
     this.iframePort = port;
 
+    setInterval(() => {
+      console.log('iframe-nip46 ping');
+      this.iframePort!.postMessage('ping');
+    }, 5000);
+
     port.onmessage = async ev => {
-      const event = ev.data;
-      if (!validateEvent(event) || !verifySignature(event)) return;
-      const parsed = await this.parseEvent(new NDKEvent(this._ndk, event));
-      if (!('method' in parsed)) {
-        this.emit(`response-${parsed.id}`, parsed);
+      console.log('iframe-nip46 got response', ev.data);
+      if (typeof ev.data === 'string' && ev.data.startsWith('errorNoKey')) {
+        const event_id = ev.data.split(':')[1];
+        const { id = '', pubkey = '' } = this.iframeRequests.get(event_id) || {};
+        if (id && pubkey && this.requests.has(id)) this.emit(`iframeRestart-${pubkey}`);
+        return;
+      }
+
+      try {
+        const event = ev.data;
+
+        if (!validateEvent(event)) throw new Error('Invalid event from iframe');
+        if (!verifySignature(event)) throw new Error('Invalid event signature from iframe');
+        const nevent = new NDKEvent(this._ndk, event);
+        const parsedEvent = await this.parseEvent(nevent);
+        if (!(parsedEvent as NDKRpcRequest).method) {
+          console.log('parsed response', parsedEvent);
+          this.emit(`response-${parsedEvent.id}`, parsedEvent);
+        }
+      } catch (e) {
+        console.log('error parsing event', e, ev.data);
       }
     };
   }
+
+  public async sendRequest(remotePubkey: string, method: string, params: string[] = [], kind = 24133, cb?: (res: NDKRpcResponse) => void): Promise<NDKRpcResponse> {
+    console.log('IframeNostrRpc.sendRequest called:', method, 'iframePort:', !!this.iframePort);
+
+    if (!this.iframePort) {
+      try {
+        this.processManager?.pause();
+        await this.ensureConnected();
+      } catch (e) {
+        console.error('Failed to ensure connection:', e);
+        if (cb) {
+          cb({
+            id: '',
+            result: '',
+            error: 'Failed to connect to relays: ' + (e as Error).message,
+            event: undefined as any,
+          });
+        }
+        throw e;
+      } finally {
+        this.processManager?.resume();
+      }
+    }
+
+    const id = this.getId();
+
+    const event = await this.createRequestEvent(id, remotePubkey, method, params, kind);
+
+    this.setResponseHandler(id, cb);
+
+    if (this.iframePort) {
+      this.iframeRequests.set(event.id, { id, pubkey: remotePubkey });
+
+      console.log('iframe-nip46 sending request to', this.peerOrigin, event.rawEvent());
+      this.iframePort.postMessage(event.rawEvent());
+    } else {
+      try {
+        await event.publish();
+        console.log('Request published to relays successfully');
+      } catch (e) {
+        console.error('Failed to publish event:', e);
+        this.clearTimeout(id);
+        this.requests.delete(id);
+        if (cb) {
+          cb({
+            id,
+            result: '',
+            error: 'Failed to publish event: ' + (e as Error).message,
+            event: undefined as any,
+          });
+        }
+        throw e;
+      }
+    }
+
+    // @ts-ignore
+    return undefined as NDKRpcResponse;
+  }
+}
+
+export class ReadyListener {
+  origin: string;
+  messages: string[];
+  promise: Promise<any>;
+
+  constructor(messages: string[], origin: string) {
+    this.origin = origin;
+    this.messages = messages;
+    this.promise = new Promise<any>(ok => {
+      console.log(new Date(), 'started listener for', this.messages);
+
+      const onReady = async (e: MessageEvent) => {
+        const originHostname = new URL(origin!).hostname;
+        const messageHostname = new URL(e.origin).hostname;
+        const validHost = messageHostname === originHostname || messageHostname.endsWith('.' + originHostname);
+        if (!validHost || !Array.isArray(e.data) || !e.data.length || !this.messages.includes(e.data[0])) {
+          return;
+        }
+
+        console.log(new Date(), 'got ready message from', e.origin, e.data);
+        window.removeEventListener('message', onReady);
+        ok(e.data);
+      };
+      window.addEventListener('message', onReady);
+    });
+  }
+
+  async wait(): Promise<any> {
+    console.log(new Date(), 'waiting for', this.messages);
+    const r = await this.promise;
+    console.log(new Date(), 'finished waiting for', this.messages, r);
+    return r;
+  }
 }
 
-/* =========================
- * Nip46Signer
- * ========================= */
 export class Nip46Signer extends NDKNip46Signer {
+  private _userPubkey: string = '';
   private _rpc: IframeNostrRpc;
 
-  constructor(ndk: NDK, localSigner: PrivateKeySigner, signerPubkey: string) {
-    const pm = new ProcessManager();
+  constructor(ndk: NDK, localSigner: PrivateKeySigner, signerPubkey: string, iframeOrigin?: string) {
     super(ndk, signerPubkey, localSigner);
 
-    this._rpc = new IframeNostrRpc(ndk, localSigner, pm);
+    this._rpc = new IframeNostrRpc(ndk, localSigner, iframeOrigin);
+    this._rpc.setUseNip44(true);
+    this._rpc.on('authUrl', (url: string) => {
+      this.emit('authUrl', url);
+    });
+
     this.rpc = this._rpc;
+  }
 
-    this._rpc.on('authUrl', url => {
-      this.emit('authUrl', url);
+  get userPubkey() {
+    return this._userPubkey;
+  }
+
+  private async setSignerPubkey(signerPubkey: string, sameAsUser: boolean = false) {
+    console.log('setSignerPubkey', signerPubkey);
+
+    this.remotePubkey = signerPubkey;
+
+    this._rpc.on(`iframeRestart-${signerPubkey}`, () => {
+      this.emit('iframeRestart');
+    });
+
+    await this.initUserPubkey(sameAsUser ? signerPubkey : '');
+  }
+
+  public async initUserPubkey(hintPubkey?: string) {
+    if (this._userPubkey) throw new Error('Already called initUserPubkey');
+
+    if (hintPubkey) {
+      this._userPubkey = hintPubkey;
+      return;
+    }
+
+    this._userPubkey = await new Promise<string>((ok, err) => {
+      if (!this.remotePubkey) throw new Error('Signer pubkey not set');
+
+      console.log('get_public_key', this.remotePubkey);
+
+      const timeoutId = setTimeout(() => {
+        err(new Error('NIP46 get_public_key timeout'));
+      }, NIP46_TIMEOUT);
+
+      this._rpc.sendRequest(this.remotePubkey, 'get_public_key', [], 24133, (response: NDKRpcResponse) => {
+        clearTimeout(timeoutId);
+        if (response.error) {
+          err(new Error(response.error));
+        } else {
+          ok(response.result);
+        }
+      });
     });
   }
+
+  public async listen(nostrConnectSecret: string) {
+    const signerPubkey = await (this.rpc as IframeNostrRpc).listen(nostrConnectSecret);
+    await this.setSignerPubkey(signerPubkey);
+  }
+
+  public async connect(token?: string, perms?: string) {
+    if (!this.remotePubkey) throw new Error('No signer pubkey');
+    await this._rpc.connect(this.remotePubkey, token, perms);
+    await this.setSignerPubkey(this.remotePubkey);
+  }
+
+  public async setListenReply(reply: any, nostrConnectSecret: string) {
+    const signerPubkey = await this._rpc.parseNostrConnectReply(reply, nostrConnectSecret);
+    await this.setSignerPubkey(signerPubkey, true);
+  }
+
+  public async createAccount2({ bunkerPubkey, name, domain, perms = '' }: { bunkerPubkey: string; name: string; domain: string; perms?: string }) {
+    const params = [name, domain, '', perms];
+
+    const r = await new Promise<NDKRpcResponse>((ok, err) => {
+      const timeoutId = setTimeout(() => {
+        err(new Error('NIP46 create_account timeout'));
+      }, NIP46_TIMEOUT);
+
+      this.rpc.sendRequest(bunkerPubkey, 'create_account', params, undefined, response => {
+        clearTimeout(timeoutId);
+        if (response.error) {
+          err(new Error(response.error));
+        } else {
+          ok(response);
+        }
+      });
+    });
+
+    console.log('create_account pubkey', r);
+    if (r.result === 'error') {
+      throw new Error(r.error);
+    }
+
+    return r.result;
+  }
 }

package/src/modules/ProcessManager.ts

@@ -2,80 +2,94 @@ import { EventEmitter } from 'tseep';
 import { CALL_TIMEOUT } from '../const';
 
 class ProcessManager extends EventEmitter {
-  private callCount = 0;
-  private callTimer?: NodeJS.Timeout;
   private paused = false;
+  private callCount: number = 0;
+  private callTimer: NodeJS.Timeout | undefined;
+
+  constructor() {
+    super();
+  }
 
-  /* 呼び出し元互換 */
   public onAuthUrl() {
+    console.log('ProcessManager.onAuthUrl called, resetting timer');
     this.resetTimer();
   }
 
-  /* 呼び出し元互換 */
   public onIframeUrl() {
+    console.log('ProcessManager.onIframeUrl called, resetting timer');
     this.resetTimer();
   }
 
   private resetTimer() {
-    if (this.paused) return;
-
-    if (this.callTimer) clearTimeout(this.callTimer);
-
+    if (this.callTimer) {
+      clearTimeout(this.callTimer);
+      console.log('ProcessManager: timer reset');
+    }
     if (this.callCount > 0) {
       this.callTimer = setTimeout(() => {
+        console.log('ProcessManager: timeout reached, emitting onCallTimeout');
         this.emit('onCallTimeout');
       }, CALL_TIMEOUT);
+      console.log(`ProcessManager: new timer set for ${CALL_TIMEOUT} ms`);
     }
   }
 
-  private startTimer() {
-    if (this.paused) return;
-    if (this.callTimer) return;
-
-    this.callTimer = setTimeout(() => {
-      this.emit('onCallTimeout');
-    }, CALL_TIMEOUT);
-  }
+  public async wait<T>(cb: () => Promise<T>): Promise<T> {
+    console.log('ProcessManager.wait called, callTimer exists:', !!this.callTimer, 'callCount:', this.callCount);
 
-  private stopTimerIfIdle() {
-    if (this.callCount === 0 && this.callTimer) {
-      clearTimeout(this.callTimer);
-      this.callTimer = undefined;
+    if (!this.callTimer) {
+      this.callTimer = setTimeout(() => {
+        console.log('ProcessManager: timeout reached, emitting onCallTimeout');
+        this.callTimer = undefined; // タイムアウト時にタイマーIDをクリア
+        this.emit('onCallTimeout');
+      }, CALL_TIMEOUT);
+      console.log(`Setting up timeout timer for ${CALL_TIMEOUT} ms`);
     }
-  }
 
-  public async wait<T>(cb: () => Promise<T>): Promise<T> {
-    if (this.callCount === 0) {
+    if (!this.callCount) {
       this.emit('onCallStart');
     }
 
     this.callCount++;
 
+    let error;
+    let result;
+
     try {
-      const p = Promise.resolve().then(cb);
-      this.startTimer();
-      return await p;
-    } finally {
-      this.callCount--;
-      this.emit('onCallEnd');
-      this.stopTimerIfIdle();
+      result = await cb();
+    } catch (e) {
+      error = e;
     }
-  }
 
-  /* 再接続などで timeout を止めるため */
-  public pause() {
-    this.paused = true;
+    this.callCount--;
+
+    this.emit('onCallEnd');
+
     if (this.callTimer) {
       clearTimeout(this.callTimer);
-      this.callTimer = undefined;
     }
+
+    this.callTimer = undefined;
+
+    if (error) {
+      throw error;
+    }
+
+    // @ts-ignore
+    return result;
+  }
+  public pause() {
+    if (this.callTimer) clearTimeout(this.callTimer);
+    this.callTimer = undefined;
+    this.paused = true;
   }
 
-  /* 再接続完了後に再開 */
   public resume() {
     this.paused = false;
     if (this.callCount > 0 && !this.callTimer) {
-      this.startTimer();
+      this.callTimer = setTimeout(() => {
+        this.emit('onCallTimeout');
+      }, CALL_TIMEOUT);
     }
   }
 }