oauth-callback 1.2.0 → 1.2.2

package/dist/mcp.js

@@ -47,16 +47,15 @@ function inMemoryStore() {
 }
 
 // node_modules/open/index.js
-import process6 from "node:process";
-import { Buffer } from "node:buffer";
+import process7 from "node:process";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { promisify as promisify5 } from "node:util";
-import childProcess from "node:child_process";
+import childProcess3 from "node:child_process";
 import fs5, { constants as fsConstants2 } from "node:fs/promises";
 
 // node_modules/wsl-utils/index.js
-import process2 from "node:process";
+import { promisify as promisify2 } from "node:util";
+import childProcess2 from "node:child_process";
 import fs4, { constants as fsConstants } from "node:fs/promises";
 
 // node_modules/is-wsl/index.js
@@ -128,7 +127,54 @@ var isWsl = () => {
 };
 var is_wsl_default = process.env.__IS_WSL_TEST__ ? isWsl : isWsl();
 
+// node_modules/powershell-utils/index.js
+import process2 from "node:process";
+import { Buffer } from "node:buffer";
+import { promisify } from "node:util";
+import childProcess from "node:child_process";
+var execFile = promisify(childProcess.execFile);
+var powerShellPath = () => `${process2.env.SYSTEMROOT || process2.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
+var executePowerShell = async (command, options = {}) => {
+  const {
+    powerShellPath: psPath,
+    ...execFileOptions
+  } = options;
+  const encodedCommand = executePowerShell.encodeCommand(command);
+  return execFile(psPath ?? powerShellPath(), [
+    ...executePowerShell.argumentsPrefix,
+    encodedCommand
+  ], {
+    encoding: "utf8",
+    ...execFileOptions
+  });
+};
+executePowerShell.argumentsPrefix = [
+  "-NoProfile",
+  "-NonInteractive",
+  "-ExecutionPolicy",
+  "Bypass",
+  "-EncodedCommand"
+];
+executePowerShell.encodeCommand = (command) => Buffer.from(command, "utf16le").toString("base64");
+executePowerShell.escapeArgument = (value) => `'${String(value).replaceAll("'", "''")}'`;
+
+// node_modules/wsl-utils/utilities.js
+function parseMountPointFromConfig(content) {
+  for (const line of content.split(`
+`)) {
+    if (/^\s*#/.test(line)) {
+      continue;
+    }
+    const match = /^\s*root\s*=\s*(?<mountPoint>"[^"]*"|'[^']*'|[^#]*)/.exec(line);
+    if (!match) {
+      continue;
+    }
+    return match.groups.mountPoint.trim().replaceAll(/^["']|["']$/g, "");
+  }
+}
+
 // node_modules/wsl-utils/index.js
+var execFile2 = promisify2(childProcess2.execFile);
 var wslDrivesMountPoint = (() => {
   const defaultMountPoint = "/mnt/";
   let mountPoint;
@@ -146,11 +192,11 @@ var wslDrivesMountPoint = (() => {
       return defaultMountPoint;
     }
     const configContent = await fs4.readFile(configFilePath, { encoding: "utf8" });
-    const configMountPoint = /(?<!#.*)root\s*=\s*(?<mountPoint>.*)/g.exec(configContent);
-    if (!configMountPoint) {
+    const parsedMountPoint = parseMountPointFromConfig(configContent);
+    if (parsedMountPoint === undefined) {
       return defaultMountPoint;
     }
-    mountPoint = configMountPoint.groups.mountPoint.trim();
+    mountPoint = parsedMountPoint;
     mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
     return mountPoint;
   };
@@ -159,11 +205,36 @@ var powerShellPathFromWsl = async () => {
   const mountPoint = await wslDrivesMountPoint();
   return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
 };
-var powerShellPath = async () => {
-  if (is_wsl_default) {
-    return powerShellPathFromWsl();
+var powerShellPath2 = is_wsl_default ? powerShellPathFromWsl : powerShellPath;
+var canAccessPowerShellPromise;
+var canAccessPowerShell = async () => {
+  canAccessPowerShellPromise ??= (async () => {
+    try {
+      const psPath = await powerShellPath2();
+      await fs4.access(psPath, fsConstants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  return canAccessPowerShellPromise;
+};
+var wslDefaultBrowser = async () => {
+  const psPath = await powerShellPath2();
+  const command = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
+  const { stdout } = await executePowerShell(command, { powerShellPath: psPath });
+  return stdout.trim();
+};
+var convertWslPathToWindows = async (path) => {
+  if (/^[a-z]+:\/\//i.test(path)) {
+    return path;
+  }
+  try {
+    const { stdout } = await execFile2("wslpath", ["-aw", path], { encoding: "utf8" });
+    return stdout.trim();
+  } catch {
+    return path;
   }
-  return `${process2.env.SYSTEMROOT || process2.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`;
 };
 
 // node_modules/define-lazy-prop/index.js
@@ -185,15 +256,15 @@ function defineLazyProperty(object, propertyName, valueGetter) {
 }
 
 // node_modules/default-browser/index.js
-import { promisify as promisify4 } from "node:util";
+import { promisify as promisify6 } from "node:util";
 import process5 from "node:process";
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile6 } from "node:child_process";
 
 // node_modules/default-browser-id/index.js
-import { promisify } from "node:util";
+import { promisify as promisify3 } from "node:util";
 import process3 from "node:process";
-import { execFile } from "node:child_process";
-var execFileAsync = promisify(execFile);
+import { execFile as execFile3 } from "node:child_process";
+var execFileAsync = promisify3(execFile3);
 async function defaultBrowserId() {
   if (process3.platform !== "darwin") {
     throw new Error("macOS only");
@@ -205,9 +276,9 @@ async function defaultBrowserId() {
 
 // node_modules/run-applescript/index.js
 import process4 from "node:process";
-import { promisify as promisify2 } from "node:util";
-import { execFile as execFile2, execFileSync } from "node:child_process";
-var execFileAsync2 = promisify2(execFile2);
+import { promisify as promisify4 } from "node:util";
+import { execFile as execFile4, execFileSync } from "node:child_process";
+var execFileAsync2 = promisify4(execFile4);
 async function runAppleScript(script, { humanReadableOutput = true } = {}) {
   if (process4.platform !== "darwin") {
     throw new Error("macOS only");
@@ -224,20 +295,28 @@ tell application "System Events" to get value of property list item "CFBundleNam
 }
 
 // node_modules/default-browser/windows.js
-import { promisify as promisify3 } from "node:util";
-import { execFile as execFile3 } from "node:child_process";
-var execFileAsync3 = promisify3(execFile3);
+import { promisify as promisify5 } from "node:util";
+import { execFile as execFile5 } from "node:child_process";
+var execFileAsync3 = promisify5(execFile5);
 var windowsBrowserProgIds = {
-  AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
-  MSEdgeDHTML: { name: "Edge", id: "com.microsoft.edge" },
   MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
-  "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" },
-  FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+  MSEdgeBHTML: { name: "Edge Beta", id: "com.microsoft.edge.beta" },
+  MSEdgeDHTML: { name: "Edge Dev", id: "com.microsoft.edge.dev" },
+  AppXq0fevzme2pys62n3e0fbqa7peapykr8v: { name: "Edge", id: "com.microsoft.edge.old" },
   ChromeHTML: { name: "Chrome", id: "com.google.chrome" },
+  ChromeBHTML: { name: "Chrome Beta", id: "com.google.chrome.beta" },
+  ChromeDHTML: { name: "Chrome Dev", id: "com.google.chrome.dev" },
+  ChromiumHTM: { name: "Chromium", id: "org.chromium.Chromium" },
   BraveHTML: { name: "Brave", id: "com.brave.Browser" },
   BraveBHTML: { name: "Brave Beta", id: "com.brave.Browser.beta" },
-  BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" }
+  BraveDHTML: { name: "Brave Dev", id: "com.brave.Browser.dev" },
+  BraveSSHTM: { name: "Brave Nightly", id: "com.brave.Browser.nightly" },
+  FirefoxURL: { name: "Firefox", id: "org.mozilla.firefox" },
+  OperaStable: { name: "Opera", id: "com.operasoftware.Opera" },
+  VivaldiHTM: { name: "Vivaldi", id: "com.vivaldi.Vivaldi" },
+  "IE.HTTP": { name: "Internet Explorer", id: "com.microsoft.ie" }
 };
+var _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
 
 class UnknownBrowserError extends Error {
 }
@@ -261,7 +340,7 @@ async function defaultBrowser(_execFileAsync = execFileAsync3) {
 }
 
 // node_modules/default-browser/index.js
-var execFileAsync4 = promisify4(execFile4);
+var execFileAsync4 = promisify6(execFile6);
 var titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
 async function defaultBrowser2() {
   if (process5.platform === "darwin") {
@@ -281,42 +360,29 @@ async function defaultBrowser2() {
   throw new Error("Only macOS, Linux, and Windows are supported");
 }
 
+// node_modules/is-in-ssh/index.js
+import process6 from "node:process";
+var isInSsh = Boolean(process6.env.SSH_CONNECTION || process6.env.SSH_CLIENT || process6.env.SSH_TTY);
+var is_in_ssh_default = isInSsh;
+
 // node_modules/open/index.js
-var execFile5 = promisify5(childProcess.execFile);
-var __dirname2 = path.dirname(fileURLToPath(import.meta.url));
+var fallbackAttemptSymbol = Symbol("fallbackAttempt");
+var __dirname2 = import.meta.url ? path.dirname(fileURLToPath(import.meta.url)) : "";
 var localXdgOpenPath = path.join(__dirname2, "xdg-open");
-var { platform, arch } = process6;
-async function getWindowsDefaultBrowserFromWsl() {
-  const powershellPath = await powerShellPath();
-  const rawCommand = String.raw`(Get-ItemProperty -Path "HKCU:\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\http\UserChoice").ProgId`;
-  const encodedCommand = Buffer.from(rawCommand, "utf16le").toString("base64");
-  const { stdout } = await execFile5(powershellPath, [
-    "-NoProfile",
-    "-NonInteractive",
-    "-ExecutionPolicy",
-    "Bypass",
-    "-EncodedCommand",
-    encodedCommand
-  ], { encoding: "utf8" });
-  const progId = stdout.trim();
-  const browserMap = {
-    ChromeHTML: "com.google.chrome",
-    BraveHTML: "com.brave.Browser",
-    MSEdgeHTM: "com.microsoft.edge",
-    FirefoxURL: "org.mozilla.firefox"
-  };
-  return browserMap[progId] ? { id: browserMap[progId] } : {};
-}
-var pTryEach = async (array, mapper) => {
-  let latestError;
-  for (const item of array) {
+var { platform, arch } = process7;
+var tryEachApp = async (apps, opener) => {
+  if (apps.length === 0) {
+    return;
+  }
+  const errors = [];
+  for (const app of apps) {
     try {
-      return await mapper(item);
+      return await opener(app);
     } catch (error) {
-      latestError = error;
+      errors.push(error);
     }
   }
-  throw latestError;
+  throw new AggregateError(errors, "Failed to open in all supported apps");
 };
 var baseOpen = async (options) => {
   options = {
@@ -326,34 +392,39 @@ var baseOpen = async (options) => {
     allowNonzeroExitCode: false,
     ...options
   };
+  const isFallbackAttempt = options[fallbackAttemptSymbol] === true;
+  delete options[fallbackAttemptSymbol];
   if (Array.isArray(options.app)) {
-    return pTryEach(options.app, (singleApp) => baseOpen({
+    return tryEachApp(options.app, (singleApp) => baseOpen({
       ...options,
-      app: singleApp
+      app: singleApp,
+      [fallbackAttemptSymbol]: true
     }));
   }
   let { name: app, arguments: appArguments = [] } = options.app ?? {};
   appArguments = [...appArguments];
   if (Array.isArray(app)) {
-    return pTryEach(app, (appName) => baseOpen({
+    return tryEachApp(app, (appName) => baseOpen({
       ...options,
       app: {
         name: appName,
         arguments: appArguments
-      }
+      },
+      [fallbackAttemptSymbol]: true
     }));
   }
   if (app === "browser" || app === "browserPrivate") {
     const ids = {
       "com.google.chrome": "chrome",
       "google-chrome.desktop": "chrome",
-      "com.brave.Browser": "brave",
+      "com.brave.browser": "brave",
       "org.mozilla.firefox": "firefox",
       "firefox.desktop": "firefox",
       "com.microsoft.msedge": "edge",
       "com.microsoft.edge": "edge",
       "com.microsoft.edgemac": "edge",
-      "microsoft-edge.desktop": "edge"
+      "microsoft-edge.desktop": "edge",
+      "com.apple.safari": "safari"
     };
     const flags = {
       chrome: "--incognito",
@@ -361,10 +432,20 @@ var baseOpen = async (options) => {
       firefox: "--private-window",
       edge: "--inPrivate"
     };
-    const browser = is_wsl_default ? await getWindowsDefaultBrowserFromWsl() : await defaultBrowser2();
+    let browser;
+    if (is_wsl_default) {
+      const progId = await wslDefaultBrowser();
+      const browserInfo = _windowsBrowserProgIdMap.get(progId);
+      browser = browserInfo ?? {};
+    } else {
+      browser = await defaultBrowser2();
+    }
     if (browser.id in ids) {
-      const browserName = ids[browser.id];
+      const browserName = ids[browser.id.toLowerCase()];
       if (app === "browserPrivate") {
+        if (browserName === "safari") {
+          throw new Error("Safari doesn't support opening in private mode via command line");
+        }
         appArguments.push(flags[browserName]);
       }
       return baseOpen({
@@ -380,6 +461,10 @@ var baseOpen = async (options) => {
   let command;
   const cliArguments = [];
   const childProcessOptions = {};
+  let shouldUseWindowsInWsl = false;
+  if (is_wsl_default && !isInsideContainer() && !is_in_ssh_default && !app) {
+    shouldUseWindowsInWsl = await canAccessPowerShell();
+  }
   if (platform === "darwin") {
     command = "open";
     if (options.wait) {
@@ -394,29 +479,35 @@ var baseOpen = async (options) => {
     if (app) {
       cliArguments.push("-a", app);
     }
-  } else if (platform === "win32" || is_wsl_default && !isInsideContainer() && !app) {
-    command = await powerShellPath();
-    cliArguments.push("-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-EncodedCommand");
+  } else if (platform === "win32" || shouldUseWindowsInWsl) {
+    command = await powerShellPath2();
+    cliArguments.push(...executePowerShell.argumentsPrefix);
     if (!is_wsl_default) {
       childProcessOptions.windowsVerbatimArguments = true;
     }
-    const encodedArguments = ["Start"];
+    if (is_wsl_default && options.target) {
+      options.target = await convertWslPathToWindows(options.target);
+    }
+    const encodedArguments = ["$ProgressPreference = 'SilentlyContinue';", "Start"];
     if (options.wait) {
       encodedArguments.push("-Wait");
     }
     if (app) {
-      encodedArguments.push(`"\`"${app}\`""`);
+      encodedArguments.push(executePowerShell.escapeArgument(app));
       if (options.target) {
         appArguments.push(options.target);
       }
     } else if (options.target) {
-      encodedArguments.push(`"${options.target}"`);
+      encodedArguments.push(executePowerShell.escapeArgument(options.target));
     }
     if (appArguments.length > 0) {
-      appArguments = appArguments.map((argument) => `"\`"${argument}\`""`);
+      appArguments = appArguments.map((argument) => executePowerShell.escapeArgument(argument));
       encodedArguments.push("-ArgumentList", appArguments.join(","));
     }
-    options.target = Buffer.from(encodedArguments.join(" "), "utf16le").toString("base64");
+    options.target = executePowerShell.encodeCommand(encodedArguments.join(" "));
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+    }
   } else {
     if (app) {
       command = app;
@@ -427,7 +518,7 @@ var baseOpen = async (options) => {
         await fs5.access(localXdgOpenPath, fsConstants2.X_OK);
         exeLocalXdgOpen = true;
       } catch {}
-      const useSystemXdgOpen = process6.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
+      const useSystemXdgOpen = process7.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
       command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
     }
     if (appArguments.length > 0) {
@@ -444,12 +535,12 @@ var baseOpen = async (options) => {
   if (options.target) {
     cliArguments.push(options.target);
   }
-  const subprocess = childProcess.spawn(command, cliArguments, childProcessOptions);
+  const subprocess = childProcess3.spawn(command, cliArguments, childProcessOptions);
   if (options.wait) {
     return new Promise((resolve, reject) => {
       subprocess.once("error", reject);
       subprocess.once("close", (exitCode) => {
-        if (!options.allowNonzeroExitCode && exitCode > 0) {
+        if (!options.allowNonzeroExitCode && exitCode !== 0) {
           reject(new Error(`Exited with code ${exitCode}`));
           return;
         }
@@ -457,8 +548,30 @@ var baseOpen = async (options) => {
       });
     });
   }
+  if (isFallbackAttempt) {
+    return new Promise((resolve, reject) => {
+      subprocess.once("error", reject);
+      subprocess.once("spawn", () => {
+        subprocess.once("close", (exitCode) => {
+          subprocess.off("error", reject);
+          if (exitCode !== 0) {
+            reject(new Error(`Exited with code ${exitCode}`));
+            return;
+          }
+          subprocess.unref();
+          resolve(subprocess);
+        });
+      });
+    });
+  }
   subprocess.unref();
-  return subprocess;
+  return new Promise((resolve, reject) => {
+    subprocess.once("error", reject);
+    subprocess.once("spawn", () => {
+      subprocess.off("error", reject);
+      resolve(subprocess);
+    });
+  });
 };
 var open = (target, options) => {
   if (typeof target !== "string") {
@@ -479,7 +592,7 @@ function detectArchBinary(binary) {
   }
   return archBinary;
 }
-function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl } = {}) {
   if (wsl && is_wsl_default) {
     return detectArchBinary(wsl);
   }
@@ -488,11 +601,14 @@ function detectPlatformBinary({ [platform]: platformBinary }, { wsl }) {
   }
   return detectArchBinary(platformBinary);
 }
-var apps = {};
+var apps = {
+  browser: "browser",
+  browserPrivate: "browserPrivate"
+};
 defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
   darwin: "google chrome",
   win32: "chrome",
-  linux: ["google-chrome", "google-chrome-stable", "chromium"]
+  linux: ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]
 }, {
   wsl: {
     ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
@@ -523,8 +639,9 @@ defineLazyProperty(apps, "edge", () => detectPlatformBinary({
 }, {
   wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
 }));
-defineLazyProperty(apps, "browser", () => "browser");
-defineLazyProperty(apps, "browserPrivate", () => "browserPrivate");
+defineLazyProperty(apps, "safari", () => detectPlatformBinary({
+  darwin: "Safari"
+}));
 var open_default = open;
 
 // src/errors.ts
@@ -605,270 +722,132 @@ function renderError(params) {
 
 // src/server.ts
 function generateCallbackHTML(params, successHtml, errorHtml) {
-  if (params.error) {
-    if (errorHtml) {
-      return errorHtml.replace(/{{error}}/g, params.error || "").replace(/{{error_description}}/g, params.error_description || "").replace(/{{error_uri}}/g, params.error_uri || "");
-    }
-    return renderError({
-      error: params.error,
-      error_description: params.error_description,
-      error_uri: params.error_uri
-    });
-  }
-  return successHtml || successTemplate;
+  if (!params.error)
+    return successHtml || successTemplate;
+  if (errorHtml)
+    return errorHtml.replace(/{{error}}/g, params.error || "").replace(/{{error_description}}/g, params.error_description || "").replace(/{{error_uri}}/g, params.error_uri || "");
+  return renderError({
+    error: params.error,
+    error_description: params.error_description,
+    error_uri: params.error_uri
+  });
 }
 
-class BunCallbackServer {
-  server;
-  callbackPromise;
-  callbackPath = "/callback";
+class BaseCallbackServer {
+  callbackListeners = new Map;
   successHtml;
   errorHtml;
   onRequest;
   abortHandler;
-  async start(options) {
-    const {
-      port,
-      hostname = "localhost",
-      successHtml,
-      errorHtml,
-      signal,
-      onRequest
-    } = options;
+  signal;
+  setup(options) {
+    const { successHtml, errorHtml, signal, onRequest } = options;
     this.successHtml = successHtml;
     this.errorHtml = errorHtml;
     this.onRequest = onRequest;
-    if (signal) {
-      if (signal.aborted) {
-        throw new Error("Operation aborted");
-      }
-      this.abortHandler = () => {
-        this.stop();
-        if (this.callbackPromise) {
-          this.callbackPromise.reject(new Error("Operation aborted"));
-        }
-      };
-      signal.addEventListener("abort", this.abortHandler);
-    }
-    this.server = Bun.serve({
-      port,
-      hostname,
-      fetch: (request) => this.handleRequest(request)
-    });
+    this.signal = signal;
+    if (!signal)
+      return;
+    if (signal.aborted)
+      throw new Error("Operation aborted");
+    this.abortHandler = () => this.stop();
+    signal.addEventListener("abort", this.abortHandler);
   }
   handleRequest(request) {
-    if (this.onRequest) {
-      this.onRequest(request);
-    }
+    this.onRequest?.(request);
     const url = new URL(request.url);
-    if (url.pathname === this.callbackPath) {
-      const params = {};
-      for (const [key, value] of url.searchParams) {
-        params[key] = value;
-      }
-      if (this.callbackPromise) {
-        this.callbackPromise.resolve(params);
-      }
-      return new Response(generateCallbackHTML(params, this.successHtml, this.errorHtml), {
-        status: 200,
-        headers: { "Content-Type": "text/html" }
-      });
-    }
-    return new Response("Not Found", { status: 404 });
+    const listener = this.callbackListeners.get(url.pathname);
+    if (!listener)
+      return new Response("Not Found", { status: 404 });
+    const params = {};
+    for (const [key, value] of url.searchParams)
+      params[key] = value;
+    listener.resolve(params);
+    return new Response(generateCallbackHTML(params, this.successHtml, this.errorHtml), {
+      status: 200,
+      headers: { "Content-Type": "text/html" }
+    });
   }
   async waitForCallback(path2, timeout) {
-    this.callbackPath = path2;
-    return new Promise((resolve, reject) => {
-      let isResolved = false;
-      const timer = setTimeout(() => {
-        if (!isResolved) {
-          isResolved = true;
-          this.callbackPromise = undefined;
-          reject(new Error(`OAuth callback timeout after ${timeout}ms waiting for ${path2}`));
-        }
-      }, timeout);
-      const wrappedResolve = (result) => {
-        if (!isResolved) {
-          isResolved = true;
-          clearTimeout(timer);
-          this.callbackPromise = undefined;
-          resolve(result);
-        }
-      };
-      const wrappedReject = (error) => {
-        if (!isResolved) {
-          isResolved = true;
-          clearTimeout(timer);
-          this.callbackPromise = undefined;
-          reject(error);
-        }
-      };
-      this.callbackPromise = { resolve: wrappedResolve, reject: wrappedReject };
-    });
+    if (this.callbackListeners.has(path2))
+      return Promise.reject(new Error(`A listener for the path "${path2}" is already active.`));
+    try {
+      return await Promise.race([
+        new Promise((resolve, reject) => {
+          this.callbackListeners.set(path2, { resolve, reject });
+        }),
+        new Promise((_, reject) => {
+          setTimeout(() => {
+            reject(new Error(`OAuth callback timeout after ${timeout}ms waiting for ${path2}`));
+          }, timeout);
+        })
+      ]);
+    } finally {
+      this.callbackListeners.delete(path2);
+    }
   }
   async stop() {
-    if (this.abortHandler) {
-      const signal = this.server?.signal;
-      if (signal) {
-        signal.removeEventListener("abort", this.abortHandler);
-      }
+    if (this.abortHandler && this.signal) {
+      this.signal.removeEventListener("abort", this.abortHandler);
       this.abortHandler = undefined;
     }
-    if (this.callbackPromise) {
-      this.callbackPromise.reject(new Error("Server stopped before callback received"));
-      this.callbackPromise = undefined;
-    }
-    if (this.server) {
-      this.server.stop();
-      this.server = undefined;
-    }
+    for (const listener of this.callbackListeners.values())
+      listener.reject(new Error("Server stopped before callback received"));
+    this.callbackListeners.clear();
+    await this.stopServer();
   }
 }
 
-class DenoCallbackServer {
+class BunCallbackServer extends BaseCallbackServer {
   server;
-  callbackPromise;
-  callbackPath = "/callback";
-  abortController;
-  successHtml;
-  errorHtml;
-  onRequest;
-  abortHandler;
   async start(options) {
-    const {
+    this.setup(options);
+    const { port, hostname = "localhost" } = options;
+    this.server = Bun.serve({
       port,
-      hostname = "localhost",
-      successHtml,
-      errorHtml,
-      signal,
-      onRequest
-    } = options;
-    this.successHtml = successHtml;
-    this.errorHtml = errorHtml;
-    this.onRequest = onRequest;
-    this.abortController = new AbortController;
-    if (signal) {
-      if (signal.aborted) {
-        throw new Error("Operation aborted");
-      }
-      this.abortHandler = () => {
-        this.abortController?.abort();
-        if (this.callbackPromise) {
-          this.callbackPromise.reject(new Error("Operation aborted"));
-        }
-      };
-      signal.addEventListener("abort", this.abortHandler);
-    }
-    this.server = Deno.serve({ port, hostname, signal: this.abortController.signal }, (request) => this.handleRequest(request));
-  }
-  handleRequest(request) {
-    if (this.onRequest) {
-      this.onRequest(request);
-    }
-    const url = new URL(request.url);
-    if (url.pathname === this.callbackPath) {
-      const params = {};
-      for (const [key, value] of url.searchParams) {
-        params[key] = value;
-      }
-      if (this.callbackPromise) {
-        this.callbackPromise.resolve(params);
-      }
-      return new Response(generateCallbackHTML(params, this.successHtml, this.errorHtml), {
-        status: 200,
-        headers: { "Content-Type": "text/html" }
-      });
-    }
-    return new Response("Not Found", { status: 404 });
-  }
-  async waitForCallback(path2, timeout) {
-    this.callbackPath = path2;
-    return new Promise((resolve, reject) => {
-      let isResolved = false;
-      const timer = setTimeout(() => {
-        if (!isResolved) {
-          isResolved = true;
-          this.callbackPromise = undefined;
-          reject(new Error(`OAuth callback timeout after ${timeout}ms waiting for ${path2}`));
-        }
-      }, timeout);
-      const wrappedResolve = (result) => {
-        if (!isResolved) {
-          isResolved = true;
-          clearTimeout(timer);
-          this.callbackPromise = undefined;
-          resolve(result);
-        }
-      };
-      const wrappedReject = (error) => {
-        if (!isResolved) {
-          isResolved = true;
-          clearTimeout(timer);
-          this.callbackPromise = undefined;
-          reject(error);
-        }
-      };
-      this.callbackPromise = { resolve: wrappedResolve, reject: wrappedReject };
+      hostname,
+      fetch: (request) => this.handleRequest(request)
     });
   }
-  async stop() {
-    if (this.abortHandler) {
-      const signal = this.server?.signal;
-      if (signal) {
-        signal.removeEventListener("abort", this.abortHandler);
-      }
-      this.abortHandler = undefined;
-    }
-    if (this.callbackPromise) {
-      this.callbackPromise.reject(new Error("Server stopped before callback received"));
-      this.callbackPromise = undefined;
-    }
-    if (this.abortController) {
-      this.abortController.abort();
-      this.abortController = undefined;
+  async stopServer() {
+    if (!this.server)
+      return;
+    while (this.server.pendingRequests > 0) {
+      await new Promise((resolve) => setTimeout(resolve, 10));
     }
+    this.server.stop();
     this.server = undefined;
   }
 }
 
-class NodeCallbackServer {
+class DenoCallbackServer extends BaseCallbackServer {
+  abortController;
+  async start(options) {
+    this.setup(options);
+    const { port, hostname = "localhost" } = options;
+    this.abortController = new AbortController;
+    options.signal?.addEventListener("abort", () => this.abortController?.abort());
+    Deno.serve({ port, hostname, signal: this.abortController.signal }, (request) => this.handleRequest(request));
+  }
+  async stopServer() {
+    if (!this.abortController)
+      return;
+    this.abortController.abort();
+    this.abortController = undefined;
+  }
+}
+
+class NodeCallbackServer extends BaseCallbackServer {
   server;
-  callbackPromise;
-  callbackPath = "/callback";
-  successHtml;
-  errorHtml;
-  onRequest;
-  abortHandler;
   async start(options) {
-    const {
-      port,
-      hostname = "localhost",
-      successHtml,
-      errorHtml,
-      signal,
-      onRequest
-    } = options;
-    this.successHtml = successHtml;
-    this.errorHtml = errorHtml;
-    this.onRequest = onRequest;
-    if (signal) {
-      if (signal.aborted) {
-        throw new Error("Operation aborted");
-      }
-      this.abortHandler = () => {
-        this.stop();
-        if (this.callbackPromise) {
-          this.callbackPromise.reject(new Error("Operation aborted"));
-        }
-      };
-      signal.addEventListener("abort", this.abortHandler);
-    }
+    this.setup(options);
+    const { port, hostname = "localhost" } = options;
     const { createServer } = await import("node:http");
     return new Promise((resolve, reject) => {
       this.server = createServer(async (req, res) => {
         try {
-          const request = this.nodeToWebRequest(req, port);
-          const response = await this.handleRequest(request);
+          const request = this.nodeToWebRequest(req, port, hostname);
+          const response = this.handleRequest(request);
           res.writeHead(response.status, Object.fromEntries(response.headers.entries()));
           const body = await response.text();
           res.end(body);
@@ -877,102 +856,44 @@ class NodeCallbackServer {
           res.end("Internal Server Error");
         }
       });
+      if (options.signal)
+        options.signal.addEventListener("abort", () => this.server?.close());
       this.server.listen(port, hostname, () => resolve());
       this.server.on("error", reject);
     });
   }
-  nodeToWebRequest(req, port) {
-    const url = new URL(req.url, `http://localhost:${port}`);
+  async stopServer() {
+    if (!this.server)
+      return;
+    this.server.closeAllConnections();
+    return new Promise((resolve) => {
+      this.server?.close(() => {
+        this.server = undefined;
+        resolve();
+      });
+    });
+  }
+  nodeToWebRequest(req, port, hostname) {
+    const host = req.headers.host || `${hostname}:${port}`;
+    const url = new URL(req.url, `http://${host}`);
     const headers = new Headers;
     for (const [key, value] of Object.entries(req.headers)) {
-      if (typeof value === "string") {
+      if (typeof value === "string")
         headers.set(key, value);
-      } else if (Array.isArray(value)) {
+      else if (Array.isArray(value))
         headers.set(key, value.join(", "));
-      }
     }
     return new Request(url.toString(), {
       method: req.method,
       headers
     });
   }
-  async handleRequest(request) {
-    if (this.onRequest) {
-      this.onRequest(request);
-    }
-    const url = new URL(request.url);
-    if (url.pathname === this.callbackPath) {
-      const params = {};
-      for (const [key, value] of url.searchParams) {
-        params[key] = value;
-      }
-      if (this.callbackPromise) {
-        this.callbackPromise.resolve(params);
-      }
-      return new Response(generateCallbackHTML(params, this.successHtml, this.errorHtml), {
-        status: 200,
-        headers: { "Content-Type": "text/html" }
-      });
-    }
-    return new Response("Not Found", { status: 404 });
-  }
-  async waitForCallback(path2, timeout) {
-    this.callbackPath = path2;
-    return new Promise((resolve, reject) => {
-      let isResolved = false;
-      const timer = setTimeout(() => {
-        if (!isResolved) {
-          isResolved = true;
-          this.callbackPromise = undefined;
-          reject(new Error(`OAuth callback timeout after ${timeout}ms waiting for ${path2}`));
-        }
-      }, timeout);
-      const wrappedResolve = (result) => {
-        if (!isResolved) {
-          isResolved = true;
-          clearTimeout(timer);
-          this.callbackPromise = undefined;
-          resolve(result);
-        }
-      };
-      const wrappedReject = (error) => {
-        if (!isResolved) {
-          isResolved = true;
-          clearTimeout(timer);
-          this.callbackPromise = undefined;
-          reject(error);
-        }
-      };
-      this.callbackPromise = { resolve: wrappedResolve, reject: wrappedReject };
-    });
-  }
-  async stop() {
-    if (this.abortHandler) {
-      const signal = this.server?.signal;
-      if (signal) {
-        signal.removeEventListener("abort", this.abortHandler);
-      }
-      this.abortHandler = undefined;
-    }
-    if (this.callbackPromise) {
-      this.callbackPromise.reject(new Error("Server stopped before callback received"));
-      this.callbackPromise = undefined;
-    }
-    if (this.server) {
-      return new Promise((resolve) => {
-        this.server.close(() => resolve());
-        this.server = undefined;
-      });
-    }
-  }
 }
 function createCallbackServer() {
-  if (typeof Bun !== "undefined") {
+  if (typeof Bun !== "undefined")
     return new BunCallbackServer;
-  }
-  if (typeof Deno !== "undefined") {
+  if (typeof Deno !== "undefined")
     return new DenoCallbackServer;
-  }
   return new NodeCallbackServer;
 }
 // src/storage/file.ts