@pilatos/bitbucket-cli 1.10.1 → 1.11.0

package/dist/index.js

@@ -26,6 +26,7 @@ var __export = (target, all) => {
       set: (newValue) => all[name] = () => newValue
     });
 };
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
 var __require = import.meta.require;
 
 // node_modules/commander/lib/error.js
@@ -13522,6 +13523,660 @@ var require_follow_redirects = __commonJS((exports, module) => {
   module.exports.wrap = wrap;
 });
 
+// node_modules/is-docker/index.js
+import fs from "fs";
+function hasDockerEnv() {
+  try {
+    fs.statSync("/.dockerenv");
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasDockerCGroup() {
+  try {
+    return fs.readFileSync("/proc/self/cgroup", "utf8").includes("docker");
+  } catch {
+    return false;
+  }
+}
+function isDocker() {
+  if (isDockerCached === undefined) {
+    isDockerCached = hasDockerEnv() || hasDockerCGroup();
+  }
+  return isDockerCached;
+}
+var isDockerCached;
+var init_is_docker = () => {};
+
+// node_modules/is-inside-container/index.js
+import fs2 from "fs";
+function isInsideContainer() {
+  if (cachedResult === undefined) {
+    cachedResult = hasContainerEnv() || isDocker();
+  }
+  return cachedResult;
+}
+var cachedResult, hasContainerEnv = () => {
+  try {
+    fs2.statSync("/run/.containerenv");
+    return true;
+  } catch {
+    return false;
+  }
+};
+var init_is_inside_container = __esm(() => {
+  init_is_docker();
+});
+
+// node_modules/is-wsl/index.js
+import process3 from "process";
+import os2 from "os";
+import fs3 from "fs";
+var isWsl = () => {
+  if (process3.platform !== "linux") {
+    return false;
+  }
+  if (os2.release().toLowerCase().includes("microsoft")) {
+    if (isInsideContainer()) {
+      return false;
+    }
+    return true;
+  }
+  try {
+    if (fs3.readFileSync("/proc/version", "utf8").toLowerCase().includes("microsoft")) {
+      return !isInsideContainer();
+    }
+  } catch {}
+  if (fs3.existsSync("/proc/sys/fs/binfmt_misc/WSLInterop") || fs3.existsSync("/run/WSL")) {
+    return !isInsideContainer();
+  }
+  return false;
+}, is_wsl_default;
+var init_is_wsl = __esm(() => {
+  init_is_inside_container();
+  is_wsl_default = process3.env.__IS_WSL_TEST__ ? isWsl : isWsl();
+});
+
+// node_modules/powershell-utils/index.js
+import process4 from "process";
+import { Buffer as Buffer2 } from "buffer";
+import { promisify } from "util";
+import childProcess from "child_process";
+var execFile, powerShellPath = () => `${process4.env.SYSTEMROOT || process4.env.windir || String.raw`C:\Windows`}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe`, executePowerShell = async (command, options = {}) => {
+  const {
+    powerShellPath: psPath,
+    ...execFileOptions
+  } = options;
+  const encodedCommand = executePowerShell.encodeCommand(command);
+  return execFile(psPath ?? powerShellPath(), [
+    ...executePowerShell.argumentsPrefix,
+    encodedCommand
+  ], {
+    encoding: "utf8",
+    ...execFileOptions
+  });
+};
+var init_powershell_utils = __esm(() => {
+  execFile = promisify(childProcess.execFile);
+  executePowerShell.argumentsPrefix = [
+    "-NoProfile",
+    "-NonInteractive",
+    "-ExecutionPolicy",
+    "Bypass",
+    "-EncodedCommand"
+  ];
+  executePowerShell.encodeCommand = (command) => Buffer2.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
+import { promisify as promisify2 } from "util";
+import childProcess2 from "child_process";
+import fs4, { constants as fsConstants } from "fs/promises";
+var execFile2, wslDrivesMountPoint, powerShellPathFromWsl = async () => {
+  const mountPoint = await wslDrivesMountPoint();
+  return `${mountPoint}c/Windows/System32/WindowsPowerShell/v1.0/powershell.exe`;
+}, powerShellPath2, canAccessPowerShellPromise, canAccessPowerShell = async () => {
+  canAccessPowerShellPromise ??= (async () => {
+    try {
+      const psPath = await powerShellPath2();
+      await fs4.access(psPath, fsConstants.X_OK);
+      return true;
+    } catch {
+      return false;
+    }
+  })();
+  return canAccessPowerShellPromise;
+}, 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();
+}, 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;
+  }
+};
+var init_wsl_utils = __esm(() => {
+  init_is_wsl();
+  init_powershell_utils();
+  init_is_wsl();
+  execFile2 = promisify2(childProcess2.execFile);
+  wslDrivesMountPoint = (() => {
+    const defaultMountPoint = "/mnt/";
+    let mountPoint;
+    return async function() {
+      if (mountPoint) {
+        return mountPoint;
+      }
+      const configFilePath = "/etc/wsl.conf";
+      let isConfigFileExists = false;
+      try {
+        await fs4.access(configFilePath, fsConstants.F_OK);
+        isConfigFileExists = true;
+      } catch {}
+      if (!isConfigFileExists) {
+        return defaultMountPoint;
+      }
+      const configContent = await fs4.readFile(configFilePath, { encoding: "utf8" });
+      const parsedMountPoint = parseMountPointFromConfig(configContent);
+      if (parsedMountPoint === undefined) {
+        return defaultMountPoint;
+      }
+      mountPoint = parsedMountPoint;
+      mountPoint = mountPoint.endsWith("/") ? mountPoint : `${mountPoint}/`;
+      return mountPoint;
+    };
+  })();
+  powerShellPath2 = is_wsl_default ? powerShellPathFromWsl : powerShellPath;
+});
+
+// node_modules/define-lazy-prop/index.js
+function defineLazyProperty(object, propertyName, valueGetter) {
+  const define = (value) => Object.defineProperty(object, propertyName, { value, enumerable: true, writable: true });
+  Object.defineProperty(object, propertyName, {
+    configurable: true,
+    enumerable: true,
+    get() {
+      const result = valueGetter();
+      define(result);
+      return result;
+    },
+    set(value) {
+      define(value);
+    }
+  });
+  return object;
+}
+
+// node_modules/default-browser-id/index.js
+import { promisify as promisify3 } from "util";
+import process5 from "process";
+import { execFile as execFile3 } from "child_process";
+async function defaultBrowserId() {
+  if (process5.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const { stdout } = await execFileAsync("defaults", ["read", "com.apple.LaunchServices/com.apple.launchservices.secure", "LSHandlers"]);
+  const match = /LSHandlerRoleAll = "(?!-)(?<id>[^"]+?)";\s+?LSHandlerURLScheme = (?:http|https);/.exec(stdout);
+  const browserId = match?.groups.id ?? "com.apple.Safari";
+  if (browserId === "com.apple.safari") {
+    return "com.apple.Safari";
+  }
+  return browserId;
+}
+var execFileAsync;
+var init_default_browser_id = __esm(() => {
+  execFileAsync = promisify3(execFile3);
+});
+
+// node_modules/run-applescript/index.js
+import process6 from "process";
+import { promisify as promisify4 } from "util";
+import { execFile as execFile4, execFileSync } from "child_process";
+async function runAppleScript(script, { humanReadableOutput = true, signal } = {}) {
+  if (process6.platform !== "darwin") {
+    throw new Error("macOS only");
+  }
+  const outputArguments = humanReadableOutput ? [] : ["-ss"];
+  const execOptions = {};
+  if (signal) {
+    execOptions.signal = signal;
+  }
+  const { stdout } = await execFileAsync2("osascript", ["-e", script, outputArguments], execOptions);
+  return stdout.trim();
+}
+var execFileAsync2;
+var init_run_applescript = __esm(() => {
+  execFileAsync2 = promisify4(execFile4);
+});
+
+// node_modules/bundle-name/index.js
+async function bundleName(bundleId) {
+  return runAppleScript(`tell application "Finder" to set app_path to application file id "${bundleId}" as string
+tell application "System Events" to get value of property list item "CFBundleName" of property list file (app_path & ":Contents:Info.plist")`);
+}
+var init_bundle_name = __esm(() => {
+  init_run_applescript();
+});
+
+// node_modules/default-browser/windows.js
+import { promisify as promisify5 } from "util";
+import { execFile as execFile5 } from "child_process";
+async function defaultBrowser(_execFileAsync = execFileAsync3) {
+  const { stdout } = await _execFileAsync("reg", [
+    "QUERY",
+    " HKEY_CURRENT_USER\\Software\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\http\\UserChoice",
+    "/v",
+    "ProgId"
+  ]);
+  const match = /ProgId\s*REG_SZ\s*(?<id>\S+)/.exec(stdout);
+  if (!match) {
+    throw new UnknownBrowserError(`Cannot find Windows browser in stdout: ${JSON.stringify(stdout)}`);
+  }
+  const { id } = match.groups;
+  const dotIndex = id.lastIndexOf(".");
+  const hyphenIndex = id.lastIndexOf("-");
+  const baseIdByDot = dotIndex === -1 ? undefined : id.slice(0, dotIndex);
+  const baseIdByHyphen = hyphenIndex === -1 ? undefined : id.slice(0, hyphenIndex);
+  return windowsBrowserProgIds[id] ?? windowsBrowserProgIds[baseIdByDot] ?? windowsBrowserProgIds[baseIdByHyphen] ?? { name: id, id };
+}
+var execFileAsync3, windowsBrowserProgIds, _windowsBrowserProgIdMap, UnknownBrowserError;
+var init_windows = __esm(() => {
+  execFileAsync3 = promisify5(execFile5);
+  windowsBrowserProgIds = {
+    MSEdgeHTM: { name: "Edge", id: "com.microsoft.edge" },
+    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" },
+    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" }
+  };
+  _windowsBrowserProgIdMap = new Map(Object.entries(windowsBrowserProgIds));
+  UnknownBrowserError = class UnknownBrowserError extends Error {
+  };
+});
+
+// node_modules/default-browser/index.js
+import { promisify as promisify6 } from "util";
+import process7 from "process";
+import { execFile as execFile6 } from "child_process";
+async function defaultBrowser2() {
+  if (process7.platform === "darwin") {
+    const id = await defaultBrowserId();
+    const name = await bundleName(id);
+    return { name, id };
+  }
+  if (process7.platform === "linux") {
+    const { stdout } = await execFileAsync4("xdg-mime", ["query", "default", "x-scheme-handler/http"]);
+    const id = stdout.trim();
+    const name = titleize(id.replace(/.desktop$/, "").replace("-", " "));
+    return { name, id };
+  }
+  if (process7.platform === "win32") {
+    return defaultBrowser();
+  }
+  throw new Error("Only macOS, Linux, and Windows are supported");
+}
+var execFileAsync4, titleize = (string) => string.toLowerCase().replaceAll(/(?:^|\s|-)\S/g, (x) => x.toUpperCase());
+var init_default_browser = __esm(() => {
+  init_default_browser_id();
+  init_bundle_name();
+  init_windows();
+  init_windows();
+  execFileAsync4 = promisify6(execFile6);
+});
+
+// node_modules/is-in-ssh/index.js
+import process8 from "process";
+var isInSsh, is_in_ssh_default;
+var init_is_in_ssh = __esm(() => {
+  isInSsh = Boolean(process8.env.SSH_CONNECTION || process8.env.SSH_CLIENT || process8.env.SSH_TTY);
+  is_in_ssh_default = isInSsh;
+});
+
+// node_modules/open/index.js
+var exports_open = {};
+__export(exports_open, {
+  openApp: () => openApp,
+  default: () => open_default,
+  apps: () => apps
+});
+import process9 from "process";
+import path from "path";
+import { fileURLToPath } from "url";
+import childProcess3 from "child_process";
+import fs5, { constants as fsConstants2 } from "fs/promises";
+function detectArchBinary(binary) {
+  if (typeof binary === "string" || Array.isArray(binary)) {
+    return binary;
+  }
+  const { [arch]: archBinary } = binary;
+  if (!archBinary) {
+    throw new Error(`${arch} is not supported`);
+  }
+  return archBinary;
+}
+function detectPlatformBinary({ [platform]: platformBinary }, { wsl } = {}) {
+  if (wsl && is_wsl_default) {
+    return detectArchBinary(wsl);
+  }
+  if (!platformBinary) {
+    throw new Error(`${platform} is not supported`);
+  }
+  return detectArchBinary(platformBinary);
+}
+var fallbackAttemptSymbol, __dirname2, localXdgOpenPath, platform, arch, tryEachApp = async (apps, opener) => {
+  if (apps.length === 0) {
+    return;
+  }
+  const errors = [];
+  for (const app of apps) {
+    try {
+      return await opener(app);
+    } catch (error) {
+      errors.push(error);
+    }
+  }
+  throw new AggregateError(errors, "Failed to open in all supported apps");
+}, baseOpen = async (options) => {
+  options = {
+    wait: false,
+    background: false,
+    newInstance: false,
+    allowNonzeroExitCode: false,
+    ...options
+  };
+  const isFallbackAttempt = options[fallbackAttemptSymbol] === true;
+  delete options[fallbackAttemptSymbol];
+  if (Array.isArray(options.app)) {
+    return tryEachApp(options.app, (singleApp) => baseOpen({
+      ...options,
+      app: singleApp,
+      [fallbackAttemptSymbol]: true
+    }));
+  }
+  let { name: app, arguments: appArguments = [] } = options.app ?? {};
+  appArguments = [...appArguments];
+  if (Array.isArray(app)) {
+    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",
+      "org.mozilla.firefox": "firefox",
+      "firefox.desktop": "firefox",
+      "com.microsoft.msedge": "edge",
+      "com.microsoft.edge": "edge",
+      "com.microsoft.edgemac": "edge",
+      "microsoft-edge.desktop": "edge",
+      "com.apple.safari": "safari"
+    };
+    const flags = {
+      chrome: "--incognito",
+      brave: "--incognito",
+      firefox: "--private-window",
+      edge: "--inPrivate"
+    };
+    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.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({
+        ...options,
+        app: {
+          name: apps[browserName],
+          arguments: appArguments
+        }
+      });
+    }
+    throw new Error(`${browser.name} is not supported as a default browser`);
+  }
+  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) {
+      cliArguments.push("--wait-apps");
+    }
+    if (options.background) {
+      cliArguments.push("--background");
+    }
+    if (options.newInstance) {
+      cliArguments.push("--new");
+    }
+    if (app) {
+      cliArguments.push("-a", app);
+    }
+  } else if (platform === "win32" || shouldUseWindowsInWsl) {
+    command = await powerShellPath2();
+    cliArguments.push(...executePowerShell.argumentsPrefix);
+    if (!is_wsl_default) {
+      childProcessOptions.windowsVerbatimArguments = true;
+    }
+    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(executePowerShell.escapeArgument(app));
+      if (options.target) {
+        appArguments.push(options.target);
+      }
+    } else if (options.target) {
+      encodedArguments.push(executePowerShell.escapeArgument(options.target));
+    }
+    if (appArguments.length > 0) {
+      appArguments = appArguments.map((argument) => executePowerShell.escapeArgument(argument));
+      encodedArguments.push("-ArgumentList", appArguments.join(","));
+    }
+    options.target = executePowerShell.encodeCommand(encodedArguments.join(" "));
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+    }
+  } else {
+    if (app) {
+      command = app;
+    } else {
+      const isBundled = !__dirname2 || __dirname2 === "/";
+      let exeLocalXdgOpen = false;
+      try {
+        await fs5.access(localXdgOpenPath, fsConstants2.X_OK);
+        exeLocalXdgOpen = true;
+      } catch {}
+      const useSystemXdgOpen = process9.versions.electron ?? (platform === "android" || isBundled || !exeLocalXdgOpen);
+      command = useSystemXdgOpen ? "xdg-open" : localXdgOpenPath;
+    }
+    if (appArguments.length > 0) {
+      cliArguments.push(...appArguments);
+    }
+    if (!options.wait) {
+      childProcessOptions.stdio = "ignore";
+      childProcessOptions.detached = true;
+    }
+  }
+  if (platform === "darwin" && appArguments.length > 0) {
+    cliArguments.push("--args", ...appArguments);
+  }
+  if (options.target) {
+    cliArguments.push(options.target);
+  }
+  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) {
+          reject(new Error(`Exited with code ${exitCode}`));
+          return;
+        }
+        resolve(subprocess);
+      });
+    });
+  }
+  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 new Promise((resolve, reject) => {
+    subprocess.once("error", reject);
+    subprocess.once("spawn", () => {
+      subprocess.off("error", reject);
+      resolve(subprocess);
+    });
+  });
+}, open = (target, options) => {
+  if (typeof target !== "string") {
+    throw new TypeError("Expected a `target`");
+  }
+  return baseOpen({
+    ...options,
+    target
+  });
+}, openApp = (name, options) => {
+  if (typeof name !== "string" && !Array.isArray(name)) {
+    throw new TypeError("Expected a valid `name`");
+  }
+  const { arguments: appArguments = [] } = options ?? {};
+  if (appArguments !== undefined && appArguments !== null && !Array.isArray(appArguments)) {
+    throw new TypeError("Expected `appArguments` as Array type");
+  }
+  return baseOpen({
+    ...options,
+    app: {
+      name,
+      arguments: appArguments
+    }
+  });
+}, apps, open_default;
+var init_open = __esm(() => {
+  init_wsl_utils();
+  init_powershell_utils();
+  init_default_browser();
+  init_is_inside_container();
+  init_is_in_ssh();
+  fallbackAttemptSymbol = Symbol("fallbackAttempt");
+  __dirname2 = import.meta.url ? path.dirname(fileURLToPath(import.meta.url)) : "";
+  localXdgOpenPath = path.join(__dirname2, "xdg-open");
+  ({ platform, arch } = process9);
+  apps = {
+    browser: "browser",
+    browserPrivate: "browserPrivate"
+  };
+  defineLazyProperty(apps, "chrome", () => detectPlatformBinary({
+    darwin: "google chrome",
+    win32: "chrome",
+    linux: ["google-chrome", "google-chrome-stable", "chromium", "chromium-browser"]
+  }, {
+    wsl: {
+      ia32: "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe",
+      x64: ["/mnt/c/Program Files/Google/Chrome/Application/chrome.exe", "/mnt/c/Program Files (x86)/Google/Chrome/Application/chrome.exe"]
+    }
+  }));
+  defineLazyProperty(apps, "brave", () => detectPlatformBinary({
+    darwin: "brave browser",
+    win32: "brave",
+    linux: ["brave-browser", "brave"]
+  }, {
+    wsl: {
+      ia32: "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe",
+      x64: ["/mnt/c/Program Files/BraveSoftware/Brave-Browser/Application/brave.exe", "/mnt/c/Program Files (x86)/BraveSoftware/Brave-Browser/Application/brave.exe"]
+    }
+  }));
+  defineLazyProperty(apps, "firefox", () => detectPlatformBinary({
+    darwin: "firefox",
+    win32: String.raw`C:\Program Files\Mozilla Firefox\firefox.exe`,
+    linux: "firefox"
+  }, {
+    wsl: "/mnt/c/Program Files/Mozilla Firefox/firefox.exe"
+  }));
+  defineLazyProperty(apps, "edge", () => detectPlatformBinary({
+    darwin: "microsoft edge",
+    win32: "msedge",
+    linux: ["microsoft-edge", "microsoft-edge-dev"]
+  }, {
+    wsl: "/mnt/c/Program Files (x86)/Microsoft/Edge/Application/msedge.exe"
+  }));
+  defineLazyProperty(apps, "safari", () => detectPlatformBinary({
+    darwin: "Safari"
+  }));
+  open_default = open;
+});
+
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -13606,6 +14261,7 @@ var ServiceTokens = {
   ContextService: "ContextService",
   OutputService: "OutputService",
   HttpClient: "HttpClient",
+  OAuthService: "OAuthService",
   VersionService: "VersionService",
   PullrequestsApi: "PullrequestsApi",
   RepositoriesApi: "RepositoriesApi",
@@ -13801,6 +14457,7 @@ class ConfigService {
     const config = await this.getConfig();
     await this.setConfig({
       ...config,
+      authMethod: "basic",
       username: credentials.username,
       apiToken: credentials.apiToken
     });
@@ -13828,6 +14485,56 @@ class ConfigService {
   getConfigPath() {
     return this.configFile;
   }
+  async getAuthMethod() {
+    const config = await this.getConfig();
+    return config.authMethod ?? "basic";
+  }
+  async getOAuthCredentials() {
+    const config = await this.getConfig();
+    const { oauthAccessToken, oauthRefreshToken, oauthExpiresAt } = config;
+    if (!oauthAccessToken || !oauthRefreshToken || !oauthExpiresAt) {
+      throw new BBError({
+        code: 1001 /* AUTH_REQUIRED */,
+        message: "OAuth authentication required. Run 'bb auth login' to authenticate."
+      });
+    }
+    return {
+      accessToken: oauthAccessToken,
+      refreshToken: oauthRefreshToken,
+      expiresAt: oauthExpiresAt
+    };
+  }
+  async setOAuthCredentials(credentials) {
+    const config = await this.getConfig();
+    const { username: _u, apiToken: _t, ...rest } = config;
+    await this.setConfig({
+      ...rest,
+      authMethod: "oauth",
+      oauthAccessToken: credentials.accessToken,
+      oauthRefreshToken: credentials.refreshToken,
+      oauthExpiresAt: credentials.expiresAt
+    });
+  }
+  async clearOAuthCredentials() {
+    const config = await this.getConfig();
+    const {
+      authMethod: _am,
+      oauthAccessToken: _at,
+      oauthRefreshToken: _rt,
+      oauthExpiresAt: _ea,
+      oauthClientId: _ci,
+      oauthClientSecret: _cs,
+      ...rest
+    } = config;
+    await this.setConfig(rest);
+  }
+  async isOAuthTokenExpired() {
+    const config = await this.getConfig();
+    if (!config.oauthExpiresAt) {
+      return true;
+    }
+    return Date.now() >= (config.oauthExpiresAt - 60) * 1000;
+  }
   clearCache() {
     this.configCache = null;
   }
@@ -18205,7 +18912,7 @@ function getRetryDelay(error, attempt) {
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-function createApiClient(configService) {
+function createApiClient(configService, oauthService) {
   const instance = axios_default.create({
     baseURL: BASE_URL,
     headers: {
@@ -18217,9 +18924,15 @@ function createApiClient(configService) {
     if (process.env.DEBUG === "true") {
       console.debug(`[HTTP] ${config.method?.toUpperCase()} ${config.url}`);
     }
-    const credentials = await configService.getCredentials();
-    const authString = Buffer.from(`${credentials.username}:${credentials.apiToken}`).toString("base64");
-    config.headers.Authorization = `Basic ${authString}`;
+    const authMethod = await configService.getAuthMethod();
+    if (authMethod === "oauth" && oauthService) {
+      const accessToken = await oauthService.getValidAccessToken();
+      config.headers.Authorization = `Bearer ${accessToken}`;
+    } else {
+      const credentials = await configService.getCredentials();
+      const authString = Buffer.from(`${credentials.username}:${credentials.apiToken}`).toString("base64");
+      config.headers.Authorization = `Basic ${authString}`;
+    }
     return config;
   }, (error) => Promise.reject(error));
   instance.interceptors.response.use((response) => {
@@ -18235,6 +18948,25 @@ function createApiClient(configService) {
         console.debug(`[HTTP] Error Response Body:`, JSON.stringify(error.response.data, null, 2));
       }
     }
+    if (error.response?.status === 401 && oauthService) {
+      const config = error.config;
+      if (config && !config.__tokenRefreshed) {
+        const authMethod = await configService.getAuthMethod();
+        if (authMethod === "oauth") {
+          try {
+            config.__tokenRefreshed = true;
+            const newToken = await oauthService.refreshAccessToken();
+            config.headers.Authorization = `Bearer ${newToken}`;
+            return instance(config);
+          } catch {
+            throw new BBError({
+              code: 1003 /* AUTH_EXPIRED */,
+              message: `OAuth token expired. Run 'bb auth login' to re-authenticate.`
+            });
+          }
+        }
+      }
+    }
     if (error.response && RETRYABLE_STATUS_CODES.has(error.response.status)) {
       const config = error.config;
       if (config) {
@@ -18285,6 +19017,405 @@ function extractErrorMessage(data) {
   }
   return;
 }
+// src/services/oauth.service.ts
+import { createServer } from "http";
+import { randomBytes } from "crypto";
+var BITBUCKET_AUTHORIZE_URL = "https://bitbucket.org/site/oauth2/authorize";
+var BITBUCKET_TOKEN_URL = "https://bitbucket.org/site/oauth2/access_token";
+var CALLBACK_PORT = 19872;
+var CALLBACK_PATH = "/callback";
+var CALLBACK_URL = `http://localhost:${CALLBACK_PORT}${CALLBACK_PATH}`;
+var AUTH_TIMEOUT_MS = 5 * 60 * 1000;
+var DEFAULT_CLIENT_ID = "ErUBvNmdYtfVHgW6J4";
+var DEFAULT_CLIENT_SECRET = "QnrWypuKXv7YvU7WJwQRza2n2QfHCEw5";
+var OAUTH_SCOPES = [
+  "account",
+  "repository",
+  "repository:admin",
+  "pullrequest",
+  "pullrequest:write"
+].join(" ");
+function generateState() {
+  return randomBytes(16).toString("hex");
+}
+
+class OAuthService {
+  configService;
+  constructor(configService) {
+    this.configService = configService;
+  }
+  async authorize(clientId, clientSecret) {
+    const resolvedClientId = clientId ?? await this.getClientId();
+    const state = generateState();
+    const authUrl = this.buildAuthUrl(resolvedClientId, state);
+    const { code } = await this.waitForCallback(authUrl, state);
+    const tokenResponse = await this.exchangeCode(code, resolvedClientId, clientSecret);
+    const expiresAt = Math.floor(Date.now() / 1000) + tokenResponse.expires_in;
+    await this.configService.setOAuthCredentials({
+      accessToken: tokenResponse.access_token,
+      refreshToken: tokenResponse.refresh_token,
+      expiresAt
+    });
+    if (clientId) {
+      await this.configService.setValue("oauthClientId", clientId);
+    }
+    if (clientSecret) {
+      await this.configService.setValue("oauthClientSecret", clientSecret);
+    }
+    const userInfo = await this.fetchUserInfo(tokenResponse.access_token);
+    return userInfo;
+  }
+  async refreshAccessToken() {
+    const credentials = await this.configService.getOAuthCredentials();
+    const clientId = await this.getClientId();
+    const clientSecret = await this.getClientSecret();
+    const params = new URLSearchParams({
+      grant_type: "refresh_token",
+      refresh_token: credentials.refreshToken
+    });
+    const response = await fetch(BITBUCKET_TOKEN_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Authorization: `Basic ${Buffer.from(`${clientId}:${clientSecret}`).toString("base64")}`
+      },
+      body: params.toString()
+    });
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new BBError({
+        code: 1003 /* AUTH_EXPIRED */,
+        message: `Failed to refresh OAuth token. Run 'bb auth login' to re-authenticate.`,
+        context: { status: response.status, body: errorBody }
+      });
+    }
+    const tokenResponse = await response.json();
+    const expiresAt = Math.floor(Date.now() / 1000) + tokenResponse.expires_in;
+    await this.configService.setOAuthCredentials({
+      accessToken: tokenResponse.access_token,
+      refreshToken: tokenResponse.refresh_token,
+      expiresAt
+    });
+    return tokenResponse.access_token;
+  }
+  async revokeToken() {
+    try {
+      const credentials = await this.configService.getOAuthCredentials();
+      const clientId = await this.getClientId();
+      const clientSecret = await this.getClientSecret();
+      const params = new URLSearchParams({
+        token: credentials.accessToken
+      });
+      await fetch("https://bitbucket.org/site/oauth2/revoke", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          Authorization: `Basic ${Buffer.from(`${clientId}:${clientSecret}`).toString("base64")}`
+        },
+        body: params.toString()
+      });
+    } catch {}
+  }
+  async getValidAccessToken() {
+    const isExpired = await this.configService.isOAuthTokenExpired();
+    if (isExpired) {
+      return this.refreshAccessToken();
+    }
+    const credentials = await this.configService.getOAuthCredentials();
+    return credentials.accessToken;
+  }
+  async getClientId() {
+    const customClientId = await this.configService.getValue("oauthClientId");
+    return customClientId ?? DEFAULT_CLIENT_ID;
+  }
+  async getClientSecret() {
+    const customSecret = await this.configService.getValue("oauthClientSecret");
+    return customSecret ?? DEFAULT_CLIENT_SECRET;
+  }
+  buildAuthUrl(clientId, state) {
+    const params = new URLSearchParams({
+      client_id: clientId,
+      response_type: "code",
+      redirect_uri: CALLBACK_URL,
+      scope: OAUTH_SCOPES,
+      state
+    });
+    return `${BITBUCKET_AUTHORIZE_URL}?${params.toString()}`;
+  }
+  async waitForCallback(authUrl, expectedState) {
+    return new Promise((resolve, reject) => {
+      let server;
+      let timeout;
+      const cleanup = () => {
+        clearTimeout(timeout);
+        server?.close();
+      };
+      timeout = setTimeout(() => {
+        cleanup();
+        reject(new BBError({
+          code: 1002 /* AUTH_INVALID */,
+          message: "Authorization timed out. Please try again."
+        }));
+      }, AUTH_TIMEOUT_MS);
+      server = createServer((req, res) => {
+        const url2 = new URL(req.url ?? "/", `http://localhost:${CALLBACK_PORT}`);
+        if (url2.pathname !== CALLBACK_PATH) {
+          res.writeHead(404);
+          res.end("Not found");
+          return;
+        }
+        const code = url2.searchParams.get("code");
+        const state = url2.searchParams.get("state");
+        const error = url2.searchParams.get("error");
+        const errorDescription = url2.searchParams.get("error_description");
+        if (error) {
+          res.writeHead(200, { "Content-Type": "text/html" });
+          res.end(this.buildErrorPage(errorDescription ?? error));
+          cleanup();
+          reject(new BBError({
+            code: 1002 /* AUTH_INVALID */,
+            message: `Authorization was denied: ${errorDescription ?? error}. Run "bb auth login --app-password" to use an API token instead.`
+          }));
+          return;
+        }
+        if (!code || state !== expectedState) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(this.buildErrorPage("Invalid callback parameters"));
+          cleanup();
+          reject(new BBError({
+            code: 1002 /* AUTH_INVALID */,
+            message: "Invalid authorization callback. Please try again."
+          }));
+          return;
+        }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end(this.buildSuccessPage());
+        cleanup();
+        resolve({ code });
+      });
+      server.on("error", (err) => {
+        cleanup();
+        if (err.code === "EADDRINUSE") {
+          reject(new BBError({
+            code: 1002 /* AUTH_INVALID */,
+            message: `Port ${CALLBACK_PORT} is already in use. Close the application using it and try again.`
+          }));
+        } else {
+          reject(new BBError({
+            code: 7001 /* NETWORK_ERROR */,
+            message: `Failed to start callback server: ${err.message}`,
+            cause: err
+          }));
+        }
+      });
+      server.listen(CALLBACK_PORT, async () => {
+        try {
+          const open2 = (await Promise.resolve().then(() => (init_open(), exports_open))).default;
+          await open2(authUrl);
+        } catch {}
+        console.error(`If the browser doesn't open, visit:
+${authUrl}
+`);
+      });
+    });
+  }
+  async exchangeCode(code, clientId, clientSecretOverride) {
+    const clientSecret = clientSecretOverride ?? await this.getClientSecret();
+    const params = new URLSearchParams({
+      grant_type: "authorization_code",
+      code,
+      redirect_uri: CALLBACK_URL
+    });
+    const response = await fetch(BITBUCKET_TOKEN_URL, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded",
+        Authorization: `Basic ${Buffer.from(`${clientId}:${clientSecret}`).toString("base64")}`
+      },
+      body: params.toString()
+    });
+    if (!response.ok) {
+      const errorBody = await response.text();
+      throw new BBError({
+        code: 1002 /* AUTH_INVALID */,
+        message: `Failed to exchange authorization code. Please try again.`,
+        context: { status: response.status, body: errorBody }
+      });
+    }
+    return await response.json();
+  }
+  async fetchUserInfo(accessToken) {
+    const response = await fetch("https://api.bitbucket.org/2.0/user", {
+      headers: { Authorization: `Bearer ${accessToken}` }
+    });
+    if (!response.ok) {
+      throw new BBError({
+        code: 1002 /* AUTH_INVALID */,
+        message: "Failed to verify OAuth credentials."
+      });
+    }
+    const user = await response.json();
+    return {
+      username: user.username,
+      displayName: user.display_name,
+      accountId: user.account_id
+    };
+  }
+  buildPageShell(content) {
+    return `<!DOCTYPE html>
+<html lang="en"><head>
+<meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>Bitbucket CLI</title>
+<link rel="preconnect" href="https://fonts.googleapis.com">
+<link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="https://fonts.googleapis.com/css2?family=IBM+Plex+Mono:wght@400;500;600&family=Space+Grotesk:wght@400;500;600;700&display=swap" rel="stylesheet">
+<style>
+*,*::before,*::after{box-sizing:border-box;margin:0;padding:0}
+:root{
+  --bg:#181c24;
+  --surface:#1e2330;
+  --border:hsl(216,24%,27%);
+  --text:#e0e4ec;
+  --text-dim:#8892a4;
+  --accent:hsl(216,100%,50%);
+  --accent-glow:hsla(216,100%,52%,0.2);
+  --accent-soft:hsla(216,100%,52%,0.09);
+  --font:'Space Grotesk',sans-serif;
+  --mono:'IBM Plex Mono',monospace;
+}
+body{
+  font-family:var(--font);
+  background:var(--bg);
+  color:var(--text);
+  min-height:100vh;
+  display:flex;
+  align-items:center;
+  justify-content:center;
+  background-image:
+    radial-gradient(ellipse 80% 60% at 50% 0%,var(--accent-glow),transparent),
+    radial-gradient(circle at 100% 100%,var(--accent-soft),transparent 50%);
+}
+.scene{
+  display:flex;
+  flex-direction:column;
+  align-items:center;
+  gap:2rem;
+  animation:enter 600ms cubic-bezier(.16,1,.3,1) both;
+}
+@keyframes enter{
+  from{opacity:0;transform:translateY(16px) scale(.97)}
+  to{opacity:1;transform:translateY(0) scale(1)}
+}
+.logo{
+  width:56px;height:56px;
+  background:var(--accent);
+  border-radius:14px;
+  display:flex;align-items:center;justify-content:center;
+  font-family:var(--mono);font-weight:700;font-size:24px;
+  color:#fff;
+  box-shadow:0 0 0 1px hsla(216,100%,70%,0.15),0 8px 32px hsla(216,100%,40%,0.25);
+  animation:logo-in 700ms cubic-bezier(.16,1,.3,1) both;
+  animation-delay:100ms;
+}
+@keyframes logo-in{
+  from{opacity:0;transform:scale(.6) rotate(-8deg)}
+  to{opacity:1;transform:scale(1) rotate(0)}
+}
+.card{
+  background:var(--surface);
+  border:1px solid var(--border);
+  border-radius:16px;
+  padding:2.5rem 3rem;
+  text-align:center;
+  max-width:420px;
+  width:100%;
+  box-shadow:0 1px 2px rgba(0,0,0,0.2),0 16px 48px rgba(0,0,0,0.15);
+  animation:card-in 600ms cubic-bezier(.16,1,.3,1) both;
+  animation-delay:200ms;
+}
+@keyframes card-in{
+  from{opacity:0;transform:translateY(12px)}
+  to{opacity:1;transform:translateY(0)}
+}
+.icon-ring{
+  width:52px;height:52px;
+  border-radius:50%;
+  display:flex;align-items:center;justify-content:center;
+  margin:0 auto 1.25rem;
+  animation:ring-pop 500ms cubic-bezier(.16,1,.3,1) both;
+  animation-delay:450ms;
+}
+@keyframes ring-pop{
+  from{opacity:0;transform:scale(.5)}
+  to{opacity:1;transform:scale(1)}
+}
+.icon-ring svg{width:28px;height:28px}
+.icon-ring.success{background:hsla(152,68%,46%,0.12);color:hsl(152,68%,46%)}
+.icon-ring.error{background:hsla(0,72%,56%,0.12);color:hsl(0,72%,56%)}
+h1{
+  font-size:1.35rem;font-weight:700;
+  letter-spacing:-0.02em;
+  margin-bottom:0.5rem;
+  animation:text-in 500ms ease both;animation-delay:500ms;
+}
+.subtitle{
+  font-size:0.9rem;color:var(--text-dim);
+  line-height:1.5;
+  animation:text-in 500ms ease both;animation-delay:580ms;
+}
+@keyframes text-in{
+  from{opacity:0;transform:translateY(6px)}
+  to{opacity:1;transform:translateY(0)}
+}
+.hint{
+  font-family:var(--mono);font-size:0.72rem;
+  color:var(--text-dim);letter-spacing:0.02em;
+  opacity:0;animation:text-in 500ms ease forwards;animation-delay:700ms;
+}
+.hint a{
+  color:var(--accent);text-decoration:none;
+  text-underline-offset:0.2em;
+}
+.hint a:hover{text-decoration:underline}
+.hint kbd{
+  background:var(--surface);border:1px solid var(--border);
+  border-radius:4px;padding:0.15em 0.45em;
+  font-family:var(--mono);font-size:0.72rem;
+}
+</style>
+</head><body>
+<div class="scene">
+  <div class="logo">bb</div>
+  <div class="card">${content}</div>
+</div>
+</body></html>`;
+  }
+  buildSuccessPage() {
+    return this.buildPageShell(`
+    <div class="icon-ring success">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round">
+        <polyline points="20 6 9 17 4 12"/>
+      </svg>
+    </div>
+    <h1>Authenticated</h1>
+    <p class="subtitle">You're all set. Close this tab and return to your terminal.</p>
+    <p class="hint"><a href="https://bitbucket-cli.paulvanderlei.com" target="_blank" rel="noopener">View documentation</a></p>
+`);
+  }
+  buildErrorPage(message) {
+    const escaped = message.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+    return this.buildPageShell(`
+    <div class="icon-ring error">
+      <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2.5" stroke-linecap="round" stroke-linejoin="round">
+        <line x1="18" y1="6" x2="6" y2="18"/><line x1="6" y1="6" x2="18" y2="18"/>
+      </svg>
+    </div>
+    <h1>Authentication Failed</h1>
+    <p class="subtitle">${escaped}</p>
+    <p class="hint"><a href="https://bitbucket-cli.paulvanderlei.com/help/troubleshooting/" target="_blank" rel="noopener">Troubleshooting guide</a></p>
+`);
+  }
+}
 // src/services/reviewer.service.ts
 function extractReviewerUuids(reviewers) {
   if (!reviewers) {
@@ -20035,12 +21166,12 @@ var RepositoriesApiAxiosParamCreator = function(configuration) {
         options: localVarRequestOptions
       };
     },
-    repositoriesWorkspaceRepoSlugFilehistoryCommitPathGet: async (commit, path, repoSlug, workspace, renames, q, sort, options = {}) => {
+    repositoriesWorkspaceRepoSlugFilehistoryCommitPathGet: async (commit, path2, repoSlug, workspace, renames, q, sort, options = {}) => {
       assertParamExists("repositoriesWorkspaceRepoSlugFilehistoryCommitPathGet", "commit", commit);
-      assertParamExists("repositoriesWorkspaceRepoSlugFilehistoryCommitPathGet", "path", path);
+      assertParamExists("repositoriesWorkspaceRepoSlugFilehistoryCommitPathGet", "path", path2);
       assertParamExists("repositoriesWorkspaceRepoSlugFilehistoryCommitPathGet", "repoSlug", repoSlug);
       assertParamExists("repositoriesWorkspaceRepoSlugFilehistoryCommitPathGet", "workspace", workspace);
-      const localVarPath = `/repositories/{workspace}/{repo_slug}/filehistory/{commit}/{path}`.replace(`{${"commit"}}`, encodeURIComponent(String(commit))).replace(`{${"path"}}`, encodeURIComponent(String(path))).replace(`{${"repo_slug"}}`, encodeURIComponent(String(repoSlug))).replace(`{${"workspace"}}`, encodeURIComponent(String(workspace)));
+      const localVarPath = `/repositories/{workspace}/{repo_slug}/filehistory/{commit}/{path}`.replace(`{${"commit"}}`, encodeURIComponent(String(commit))).replace(`{${"path"}}`, encodeURIComponent(String(path2))).replace(`{${"repo_slug"}}`, encodeURIComponent(String(repoSlug))).replace(`{${"workspace"}}`, encodeURIComponent(String(workspace)));
       const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
       let baseOptions;
       if (configuration) {
@@ -20580,12 +21711,12 @@ var RepositoriesApiAxiosParamCreator = function(configuration) {
         options: localVarRequestOptions
       };
     },
-    repositoriesWorkspaceRepoSlugSrcCommitPathGet: async (commit, path, repoSlug, workspace, format, q, sort, maxDepth, options = {}) => {
+    repositoriesWorkspaceRepoSlugSrcCommitPathGet: async (commit, path2, repoSlug, workspace, format, q, sort, maxDepth, options = {}) => {
       assertParamExists("repositoriesWorkspaceRepoSlugSrcCommitPathGet", "commit", commit);
-      assertParamExists("repositoriesWorkspaceRepoSlugSrcCommitPathGet", "path", path);
+      assertParamExists("repositoriesWorkspaceRepoSlugSrcCommitPathGet", "path", path2);
       assertParamExists("repositoriesWorkspaceRepoSlugSrcCommitPathGet", "repoSlug", repoSlug);
       assertParamExists("repositoriesWorkspaceRepoSlugSrcCommitPathGet", "workspace", workspace);
-      const localVarPath = `/repositories/{workspace}/{repo_slug}/src/{commit}/{path}`.replace(`{${"commit"}}`, encodeURIComponent(String(commit))).replace(`{${"path"}}`, encodeURIComponent(String(path))).replace(`{${"repo_slug"}}`, encodeURIComponent(String(repoSlug))).replace(`{${"workspace"}}`, encodeURIComponent(String(workspace)));
+      const localVarPath = `/repositories/{workspace}/{repo_slug}/src/{commit}/{path}`.replace(`{${"commit"}}`, encodeURIComponent(String(commit))).replace(`{${"path"}}`, encodeURIComponent(String(path2))).replace(`{${"repo_slug"}}`, encodeURIComponent(String(repoSlug))).replace(`{${"workspace"}}`, encodeURIComponent(String(workspace)));
       const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
       let baseOptions;
       if (configuration) {
@@ -20759,8 +21890,8 @@ var RepositoriesApiFp = function(configuration) {
       const localVarOperationServerBasePath = operationServerMap["RepositoriesApi.repositoriesWorkspaceRepoSlugDelete"]?.[localVarOperationServerIndex]?.url;
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
     },
-    async repositoriesWorkspaceRepoSlugFilehistoryCommitPathGet(commit, path, repoSlug, workspace, renames, q, sort, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.repositoriesWorkspaceRepoSlugFilehistoryCommitPathGet(commit, path, repoSlug, workspace, renames, q, sort, options);
+    async repositoriesWorkspaceRepoSlugFilehistoryCommitPathGet(commit, path2, repoSlug, workspace, renames, q, sort, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.repositoriesWorkspaceRepoSlugFilehistoryCommitPathGet(commit, path2, repoSlug, workspace, renames, q, sort, options);
       const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
       const localVarOperationServerBasePath = operationServerMap["RepositoriesApi.repositoriesWorkspaceRepoSlugFilehistoryCommitPathGet"]?.[localVarOperationServerIndex]?.url;
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
@@ -20885,8 +22016,8 @@ var RepositoriesApiFp = function(configuration) {
       const localVarOperationServerBasePath = operationServerMap["RepositoriesApi.repositoriesWorkspaceRepoSlugPut"]?.[localVarOperationServerIndex]?.url;
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
     },
-    async repositoriesWorkspaceRepoSlugSrcCommitPathGet(commit, path, repoSlug, workspace, format, q, sort, maxDepth, options) {
-      const localVarAxiosArgs = await localVarAxiosParamCreator.repositoriesWorkspaceRepoSlugSrcCommitPathGet(commit, path, repoSlug, workspace, format, q, sort, maxDepth, options);
+    async repositoriesWorkspaceRepoSlugSrcCommitPathGet(commit, path2, repoSlug, workspace, format, q, sort, maxDepth, options) {
+      const localVarAxiosArgs = await localVarAxiosParamCreator.repositoriesWorkspaceRepoSlugSrcCommitPathGet(commit, path2, repoSlug, workspace, format, q, sort, maxDepth, options);
       const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
       const localVarOperationServerBasePath = operationServerMap["RepositoriesApi.repositoriesWorkspaceRepoSlugSrcCommitPathGet"]?.[localVarOperationServerIndex]?.url;
       return (axios2, basePath) => createRequestFunction(localVarAxiosArgs, axios_default, BASE_PATH, configuration)(axios2, localVarOperationServerBasePath || basePath);
@@ -21223,14 +22354,45 @@ class BaseCommand {
 class LoginCommand extends BaseCommand {
   configService;
   usersApi;
+  oauthService;
   name = "login";
-  description = "Authenticate with Bitbucket using an API token";
-  constructor(configService, usersApi, output) {
+  description = "Authenticate with Bitbucket";
+  constructor(configService, usersApi, oauthService, output) {
     super(output);
     this.configService = configService;
     this.usersApi = usersApi;
+    this.oauthService = oauthService;
   }
   async execute(options, context) {
+    const useAppPassword = options.appPassword || options.username !== undefined || options.password !== undefined || process.env.BB_API_TOKEN !== undefined;
+    if (useAppPassword) {
+      return this.loginWithApiToken(options, context);
+    }
+    return this.loginWithOAuth(options, context);
+  }
+  async loginWithOAuth(options, context) {
+    this.output.info("Opening browser to authenticate with Bitbucket...");
+    try {
+      const userInfo = await this.oauthService.authorize(options.clientId, options.clientSecret);
+      if (context.globalOptions.json) {
+        this.output.json({
+          authenticated: true,
+          method: "oauth",
+          user: {
+            username: userInfo.username,
+            displayName: userInfo.displayName,
+            accountId: userInfo.accountId
+          }
+        });
+        return;
+      }
+      this.output.success(`Logged in as ${userInfo.displayName} (${userInfo.username})`);
+    } catch (error) {
+      await this.configService.clearOAuthCredentials();
+      throw error;
+    }
+  }
+  async loginWithApiToken(options, context) {
     const username = options.username || process.env.BB_USERNAME;
     const apiToken = options.password || process.env.BB_API_TOKEN;
     if (!username) {
@@ -21245,6 +22407,7 @@ class LoginCommand extends BaseCommand {
         message: "API token is required. Use --password option or set BB_API_TOKEN environment variable."
       });
     }
+    await this.configService.clearOAuthCredentials();
     await this.configService.setCredentials({ username, apiToken });
     try {
       const response = await this.usersApi.userGet();
@@ -21252,6 +22415,7 @@ class LoginCommand extends BaseCommand {
       if (context.globalOptions.json) {
         this.output.json({
           authenticated: true,
+          method: "api_token",
           user: {
             username: user.username,
             displayName: user.display_name,
@@ -21274,14 +22438,22 @@ class LoginCommand extends BaseCommand {
 // src/commands/auth/logout.command.ts
 class LogoutCommand extends BaseCommand {
   configService;
+  oauthService;
   name = "logout";
   description = "Log out of Bitbucket";
-  constructor(configService, output) {
+  constructor(configService, oauthService, output) {
     super(output);
     this.configService = configService;
+    this.oauthService = oauthService;
   }
   async execute(_options, context) {
-    await this.configService.clearCredentials();
+    const authMethod = await this.configService.getAuthMethod();
+    if (authMethod === "oauth") {
+      await this.oauthService.revokeToken();
+      await this.configService.clearOAuthCredentials();
+    } else {
+      await this.configService.clearCredentials();
+    }
     if (context.globalOptions.json) {
       this.output.json({ authenticated: false, success: true });
       return;
@@ -21303,7 +22475,10 @@ class StatusCommand extends BaseCommand {
   }
   async execute(_options, context) {
     const config = await this.configService.getConfig();
-    if (!config.username || !config.apiToken) {
+    const authMethod = await this.configService.getAuthMethod();
+    const hasBasicAuth = config.username && config.apiToken;
+    const hasOAuth = config.oauthAccessToken && config.oauthRefreshToken;
+    if (!hasBasicAuth && !hasOAuth) {
       if (context.globalOptions.json) {
         this.output.json({ authenticated: false });
         return;
@@ -21316,21 +22491,41 @@ class StatusCommand extends BaseCommand {
       const response = await this.usersApi.userGet();
       const user = response.data;
       if (context.globalOptions.json) {
-        this.output.json({
+        const jsonOutput = {
           authenticated: true,
+          method: authMethod,
           user: {
             username: user.username,
             displayName: user.display_name,
             accountId: user.account_id
           },
           defaultWorkspace: config.defaultWorkspace
-        });
+        };
+        if (authMethod === "oauth" && config.oauthExpiresAt) {
+          jsonOutput.tokenExpiresAt = config.oauthExpiresAt;
+        }
+        this.output.json(jsonOutput);
         return;
       }
       this.output.success("Logged in to Bitbucket");
+      this.output.text(`  Authentication: ${this.output.highlight(authMethod === "oauth" ? "OAuth" : "API Token")}`);
       this.output.text(`  Username: ${this.output.highlight(user.username ?? "")}`);
       this.output.text(`  Display name: ${user.display_name}`);
       this.output.text(`  Account ID: ${user.account_id}`);
+      if (authMethod === "oauth" && config.oauthExpiresAt) {
+        const expiresIn = config.oauthExpiresAt - Math.floor(Date.now() / 1000);
+        if (expiresIn > 0) {
+          const hours = Math.floor(expiresIn / 3600);
+          const minutes = Math.floor(expiresIn % 3600 / 60);
+          const parts = [];
+          if (hours > 0)
+            parts.push(`${hours}h`);
+          parts.push(`${minutes}m`);
+          this.output.text(`  Token expires: in ${parts.join(" ")}`);
+        } else {
+          this.output.text(`  Token expires: ${this.output.yellow("expired (will refresh automatically)")}`);
+        }
+      }
       if (config.defaultWorkspace) {
         this.output.text(`  Default workspace: ${this.output.highlight(config.defaultWorkspace)}`);
       }
@@ -21347,13 +22542,25 @@ class StatusCommand extends BaseCommand {
 // src/commands/auth/token.command.ts
 class TokenCommand extends BaseCommand {
   configService;
+  oauthService;
   name = "token";
   description = "Print the current access token";
-  constructor(configService, output) {
+  constructor(configService, oauthService, output) {
     super(output);
     this.configService = configService;
+    this.oauthService = oauthService;
   }
   async execute(_options, context) {
+    const authMethod = await this.configService.getAuthMethod();
+    if (authMethod === "oauth") {
+      const accessToken = await this.oauthService.getValidAccessToken();
+      if (context.globalOptions.json) {
+        this.output.json({ token: accessToken, type: "bearer" });
+        return;
+      }
+      this.output.text(accessToken);
+      return;
+    }
     const credentials = await this.configService.getCredentials();
     if (!credentials.username || !credentials.apiToken) {
       throw new BBError({
@@ -21363,7 +22570,7 @@ class TokenCommand extends BaseCommand {
     }
     const token = Buffer.from(`${credentials.username}:${credentials.apiToken}`).toString("base64");
     if (context.globalOptions.json) {
-      this.output.json({ token });
+      this.output.json({ token, type: "basic" });
       return;
     }
     this.output.text(token);
@@ -21488,8 +22695,8 @@ function getCommitFilePath(file) {
   if (!isRecord(file)) {
     return;
   }
-  const path = file.path;
-  return typeof path === "string" && path.length > 0 ? path : undefined;
+  const path2 = file.path;
+  return typeof path2 === "string" && path2.length > 0 ? path2 : undefined;
 }
 function parseDiffstatFile(value) {
   if (!isRecord(value)) {
@@ -22270,7 +23477,7 @@ class ViewPRCommand extends BaseCommand {
 }
 
 // src/commands/pr/edit.command.ts
-import * as fs from "fs";
+import * as fs6 from "fs";
 class EditPRCommand extends BaseCommand {
   pullrequestsApi;
   contextService;
@@ -22324,7 +23531,7 @@ class EditPRCommand extends BaseCommand {
     let body = options.body;
     if (options.bodyFile) {
       try {
-        body = fs.readFileSync(options.bodyFile, "utf-8");
+        body = fs6.readFileSync(options.bodyFile, "utf-8");
       } catch (err) {
         throw new BBError({
           code: 9999 /* UNKNOWN */,
@@ -22596,8 +23803,8 @@ class CheckoutPRCommand extends BaseCommand {
 
 // src/commands/pr/diff.command.ts
 import { exec } from "child_process";
-import { promisify } from "util";
-var execAsync = promisify(exec);
+import { promisify as promisify7 } from "util";
+var execAsync = promisify7(exec);
 
 class DiffPRCommand extends BaseCommand {
   pullrequestsApi;
@@ -22709,11 +23916,11 @@ class DiffPRCommand extends BaseCommand {
   }
   async openInBrowser(url2) {
     this.output.info(`Opening ${url2} in your browser...`);
-    const platform = process.platform;
+    const platform2 = process.platform;
     let command;
-    if (platform === "darwin") {
+    if (platform2 === "darwin") {
       command = `open "${url2}"`;
-    } else if (platform === "win32") {
+    } else if (platform2 === "win32") {
       command = `start "" "${url2}"`;
     } else {
       command = `xdg-open "${url2}"`;
@@ -23676,24 +24883,32 @@ function bootstrap(options = {}) {
   container.register(ServiceTokens.ConfigService, () => new ConfigService);
   container.register(ServiceTokens.GitService, () => new GitService);
   container.register(ServiceTokens.OutputService, () => new OutputService({ noColor: options.noColor }));
+  container.register(ServiceTokens.OAuthService, () => {
+    const configService = container.resolve(ServiceTokens.ConfigService);
+    return new OAuthService(configService);
+  });
   container.register(ServiceTokens.PullrequestsApi, () => {
     const configService = container.resolve(ServiceTokens.ConfigService);
-    const axiosInstance = createApiClient(configService);
+    const oauthService = container.resolve(ServiceTokens.OAuthService);
+    const axiosInstance = createApiClient(configService, oauthService);
     return new PullrequestsApi(undefined, undefined, axiosInstance);
   });
   container.register(ServiceTokens.RepositoriesApi, () => {
     const configService = container.resolve(ServiceTokens.ConfigService);
-    const axiosInstance = createApiClient(configService);
+    const oauthService = container.resolve(ServiceTokens.OAuthService);
+    const axiosInstance = createApiClient(configService, oauthService);
     return new RepositoriesApi(undefined, undefined, axiosInstance);
   });
   container.register(ServiceTokens.UsersApi, () => {
     const configService = container.resolve(ServiceTokens.ConfigService);
-    const axiosInstance = createApiClient(configService);
+    const oauthService = container.resolve(ServiceTokens.OAuthService);
+    const axiosInstance = createApiClient(configService, oauthService);
     return new UsersApi(undefined, undefined, axiosInstance);
   });
   container.register(ServiceTokens.CommitStatusesApi, () => {
     const configService = container.resolve(ServiceTokens.ConfigService);
-    const axiosInstance = createApiClient(configService);
+    const oauthService = container.resolve(ServiceTokens.OAuthService);
+    const axiosInstance = createApiClient(configService, oauthService);
     return new CommitStatusesApi(undefined, undefined, axiosInstance);
   });
   container.register(ServiceTokens.ContextService, () => {
@@ -23704,13 +24919,15 @@ function bootstrap(options = {}) {
   container.register(ServiceTokens.LoginCommand, () => {
     const configService = container.resolve(ServiceTokens.ConfigService);
     const usersApi = container.resolve(ServiceTokens.UsersApi);
+    const oauthService = container.resolve(ServiceTokens.OAuthService);
     const output = container.resolve(ServiceTokens.OutputService);
-    return new LoginCommand(configService, usersApi, output);
+    return new LoginCommand(configService, usersApi, oauthService, output);
   });
   container.register(ServiceTokens.LogoutCommand, () => {
     const configService = container.resolve(ServiceTokens.ConfigService);
+    const oauthService = container.resolve(ServiceTokens.OAuthService);
     const output = container.resolve(ServiceTokens.OutputService);
-    return new LogoutCommand(configService, output);
+    return new LogoutCommand(configService, oauthService, output);
   });
   container.register(ServiceTokens.StatusCommand, () => {
     const configService = container.resolve(ServiceTokens.ConfigService);
@@ -23720,8 +24937,9 @@ function bootstrap(options = {}) {
   });
   container.register(ServiceTokens.TokenCommand, () => {
     const configService = container.resolve(ServiceTokens.ConfigService);
+    const oauthService = container.resolve(ServiceTokens.OAuthService);
     const output = container.resolve(ServiceTokens.OutputService);
-    return new TokenCommand(configService, output);
+    return new TokenCommand(configService, oauthService, output);
   });
   container.register(ServiceTokens.CloneCommand, () => {
     const gitService = container.resolve(ServiceTokens.GitService);
@@ -24064,14 +25282,16 @@ cli.name("bb").description("A command-line interface for Bitbucket Cloud").versi
   } catch {}
 });
 var authCmd = new Command("auth").description("Authenticate with Bitbucket");
-authCmd.command("login").description("Authenticate with Bitbucket using an API token").option("-u, --username <username>", "Bitbucket username").option("-p, --password <password>", "Bitbucket API token").addHelpText("after", buildHelpText({
+authCmd.command("login").description("Authenticate with Bitbucket (OAuth or API token)").option("-u, --username <username>", "Bitbucket username (implies API token auth)").option("-p, --password <password>", "Bitbucket API token (implies API token auth)").option("--app-password", "Use API token authentication instead of OAuth").option("--client-id <clientId>", "Custom OAuth consumer client ID").option("--client-secret <clientSecret>", "Custom OAuth consumer client secret").addHelpText("after", buildHelpText({
   examples: [
-    "bb auth login -u myuser -p mytoken",
+    "bb auth login",
+    "bb auth login --app-password -u myuser -p mytoken",
+    "bb auth login --client-id <id>",
     "BB_USERNAME=myuser BB_API_TOKEN=mytoken bb auth login"
   ],
   envVars: {
     BB_USERNAME: "Used when --username is not provided",
-    BB_API_TOKEN: "Used when --password is not provided"
+    BB_API_TOKEN: "Used when --password is not provided (implies API token auth)"
   }
 })).action(async (options) => {
   await runCommand(ServiceTokens.LoginCommand, options, cli);