@pilatos/bitbucket-cli 0.3.1 → 1.0.0

package/README.md

@@ -123,7 +123,7 @@ Manage your Bitbucket authentication securely.
 
 | Command | Description |
 |---------|-------------|
-| `bb auth login` | Authenticate with Bitbucket using an App Password |
+| `bb auth login` | Authenticate with Bitbucket using an API Token |
 | `bb auth logout` | Log out and remove stored credentials |
 | `bb auth status` | Check your current authentication status |
 | `bb auth token` | Print your current access token |
@@ -211,19 +211,21 @@ These options work with any command:
 
 ## Authentication Setup
 
-The CLI uses **Bitbucket App Passwords** for secure authentication. Here's how to set it up:
+The CLI uses **Bitbucket API Tokens** for secure authentication. Here's how to set it up:
 
-### Step 1: Create an App Password
+> **Note**: As of September 9, 2025, Bitbucket app passwords are deprecated and can no longer be created. All existing app passwords will be disabled on June 9, 2026. Use API tokens instead.
 
-1. Go to [Bitbucket App Passwords](https://bitbucket.org/account/settings/app-passwords/)
-2. Click **"Create app password"**
+### Step 1: Create an API Token
+
+1. Go to [Bitbucket API Tokens](https://bitbucket.org/account/settings/api-tokens/)
+2. Click **"Create API token"**
 3. Enter a descriptive label (e.g., "bb CLI")
-4. Select the required permissions:
+4. Select the required scopes:
    - **Account:** Read
    - **Repositories:** Read, Write, Admin (as needed)
    - **Pull requests:** Read, Write
 5. Click **"Create"**
-6. **Copy the generated password** (you won't see it again!)
+6. **Copy the generated token** (you won't see it again!)
 
 ### Step 2: Authenticate
 
@@ -231,7 +233,7 @@ The CLI uses **Bitbucket App Passwords** for secure authentication. Here's how t
 bb auth login
 ```
 
-Enter your Bitbucket username and the App Password when prompted.
+Enter your Bitbucket username and the API Token when prompted.
 
 ### Step 3: Verify
 

package/dist/index.js

@@ -32653,14 +32653,14 @@ var require_promisify = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", {
     value: true
   });
-  exports.promisify = promisify;
+  exports.promisify = promisify2;
   var customArgumentsToken = "__ES6-PROMISIFY--CUSTOM-ARGUMENTS__";
-  function promisify(original) {
+  function promisify2(original) {
     if (typeof original !== "function") {
       throw new TypeError("Argument to promisify must be a function");
     }
     var argumentNames = original[customArgumentsToken];
-    var ES6Promise = promisify.Promise || Promise;
+    var ES6Promise = promisify2.Promise || Promise;
     if (typeof ES6Promise !== "function") {
       throw new Error("No Promise implementation found; do you need a polyfill?");
     }
@@ -32693,8 +32693,8 @@ var require_promisify = __commonJS((exports) => {
       });
     };
   }
-  promisify.argumentNames = customArgumentsToken;
-  promisify.Promise = undefined;
+  promisify2.argumentNames = customArgumentsToken;
+  promisify2.Promise = undefined;
 });
 
 // node_modules/mkdirp/index.js
@@ -32793,8 +32793,8 @@ var require_systemShell = __commonJS((exports, module) => {
 var require_exists = __commonJS((exports, module) => {
   var fs = __require("fs");
   var untildify = require_untildify();
-  var { promisify } = require_promisify();
-  var readFile = promisify(fs.readFile);
+  var { promisify: promisify2 } = require_promisify();
+  var readFile = promisify2(fs.readFile);
   module.exports = async (file) => {
     let fileExists;
     try {
@@ -32841,13 +32841,13 @@ var require_installer = __commonJS((exports, module) => {
   var fs = __require("fs");
   var path = __require("path");
   var untildify = require_untildify();
-  var { promisify } = require_promisify();
-  var mkdirp = promisify(require_mkdirp());
+  var { promisify: promisify2 } = require_promisify();
+  var mkdirp = promisify2(require_mkdirp());
   var { tabtabDebug, systemShell, exists } = require_utils2();
   var debug = tabtabDebug("tabtab:installer");
-  var readFile = promisify(fs.readFile);
-  var writeFile = promisify(fs.writeFile);
-  var unlink = promisify(fs.unlink);
+  var readFile = promisify2(fs.readFile);
+  var writeFile = promisify2(fs.writeFile);
+  var unlink = promisify2(fs.unlink);
   var {
     BASH_LOCATION,
     FISH_LOCATION,
@@ -33262,6 +33262,7 @@ var ServiceTokens = {
   ApprovePRCommand: "ApprovePRCommand",
   DeclinePRCommand: "DeclinePRCommand",
   CheckoutPRCommand: "CheckoutPRCommand",
+  DiffPRCommand: "DiffPRCommand",
   GetConfigCommand: "GetConfigCommand",
   SetConfigCommand: "SetConfigCommand",
   ListConfigCommand: "ListConfigCommand",
@@ -33465,14 +33466,14 @@ class ConfigService {
     if (!configResult.success) {
       return configResult;
     }
-    const { username, appPassword } = configResult.value;
-    if (!username || !appPassword) {
+    const { username, apiToken } = configResult.value;
+    if (!username || !apiToken) {
       return Result.err(new BBError({
         code: 1001 /* AUTH_REQUIRED */,
         message: "Authentication required. Run 'bb auth login' to authenticate."
       }));
     }
-    return Result.ok({ username, appPassword });
+    return Result.ok({ username, apiToken });
   }
   async setCredentials(credentials) {
     const configResult = await this.getConfig();
@@ -33482,7 +33483,7 @@ class ConfigService {
     return this.setConfig({
       ...configResult.value,
       username: credentials.username,
-      appPassword: credentials.appPassword
+      apiToken: credentials.apiToken
     });
   }
   async clearConfig() {
@@ -34253,11 +34254,11 @@ class HttpClient {
     if (!credentialsResult.success) {
       return credentialsResult;
     }
-    const { username, appPassword } = credentialsResult.value;
-    const encoded = Buffer.from(`${username}:${appPassword}`).toString("base64");
+    const { username, apiToken } = credentialsResult.value;
+    const encoded = Buffer.from(`${username}:${apiToken}`).toString("base64");
     return Result.ok(`Basic ${encoded}`);
   }
-  async request(method, path, body) {
+  async request(method, path, body, acceptText = false) {
     const authResult = await this.getAuthHeader();
     if (!authResult.success) {
       return authResult;
@@ -34265,7 +34266,7 @@ class HttpClient {
     const headers = {
       Authorization: authResult.value,
       "Content-Type": "application/json",
-      Accept: "application/json"
+      Accept: acceptText ? "text/plain" : "application/json"
     };
     const url = `${this.baseUrl}${path}`;
     try {
@@ -34278,7 +34279,7 @@ class HttpClient {
         signal: controller.signal
       });
       clearTimeout(timeoutId);
-      return this.handleResponse(response);
+      return acceptText ? this.handleTextResponse(response) : this.handleResponse(response);
     } catch (error) {
       if (error instanceof Error && error.name === "AbortError") {
         return Result.err(new BBError({
@@ -34322,6 +34323,33 @@ class HttpClient {
       }));
     }
   }
+  async handleTextResponse(response) {
+    if (!response.ok) {
+      let errorBody;
+      try {
+        errorBody = await response.json();
+      } catch {
+        errorBody = await response.text();
+      }
+      const message = this.extractErrorMessage(errorBody, response.statusText);
+      return Result.err(new APIError(message, response.status, errorBody, {
+        url: response.url
+      }));
+    }
+    if (response.status === 204) {
+      return Result.ok(undefined);
+    }
+    try {
+      const data = await response.text();
+      return Result.ok(data);
+    } catch (error) {
+      return Result.err(new BBError({
+        code: 2001 /* API_REQUEST_FAILED */,
+        message: "Failed to read response text",
+        cause: error instanceof Error ? error : undefined
+      }));
+    }
+  }
   extractErrorMessage(body, fallback) {
     if (typeof body === "object" && body !== null) {
       const obj = body;
@@ -34340,6 +34368,9 @@ class HttpClient {
   async get(path) {
     return this.request("GET", path);
   }
+  async getText(path) {
+    return this.request("GET", path, undefined, true);
+  }
   async post(path, body) {
     return this.request("POST", path, body);
   }
@@ -34408,6 +34439,12 @@ class PullRequestRepository {
   async decline(workspace, repoSlug, id) {
     return this.httpClient.post(this.buildPath(workspace, repoSlug, `/${id}/decline`));
   }
+  async getDiff(workspace, repoSlug, id) {
+    return this.httpClient.getText(this.buildPath(workspace, repoSlug, `/${id}/diff`));
+  }
+  async getDiffstat(workspace, repoSlug, id) {
+    return this.httpClient.get(this.buildPath(workspace, repoSlug, `/${id}/diffstat`));
+  }
 }
 // src/core/base-command.ts
 class BaseCommand {
@@ -34446,7 +34483,7 @@ class LoginCommand extends BaseCommand {
   configService;
   userRepositoryFactory;
   name = "login";
-  description = "Authenticate with Bitbucket using an app password";
+  description = "Authenticate with Bitbucket using an API token";
   constructor(configService, userRepositoryFactory, output) {
     super(output);
     this.configService = configService;
@@ -34454,15 +34491,20 @@ class LoginCommand extends BaseCommand {
   }
   async execute(options, context) {
     const username = options.username || process.env.BB_USERNAME;
-    const appPassword = options.password || process.env.BB_APP_PASSWORD;
+    const apiToken = options.password || process.env.BB_API_TOKEN;
     if (!username) {
-      return Result.err(new ValidationError("username", "Username is required. Use --username option or set BB_USERNAME environment variable."));
+      const error = Result.err(new ValidationError("username", "Username is required. Use --username option or set BB_USERNAME environment variable."));
+      this.handleResult(error, context);
+      return error;
     }
-    if (!appPassword) {
-      return Result.err(new ValidationError("password", "App password is required. Use --password option or set BB_APP_PASSWORD environment variable."));
+    if (!apiToken) {
+      const error = Result.err(new ValidationError("password", "API token is required. Use --password option or set BB_API_TOKEN environment variable."));
+      this.handleResult(error, context);
+      return error;
     }
-    const setResult = await this.configService.setCredentials({ username, appPassword });
+    const setResult = await this.configService.setCredentials({ username, apiToken });
     if (!setResult.success) {
+      this.handleResult(setResult, context);
       return setResult;
     }
     const userRepository = this.userRepositoryFactory(this.configService);
@@ -34515,7 +34557,7 @@ class StatusCommand extends BaseCommand {
       return configResult;
     }
     const config = configResult.value;
-    if (!config.username || !config.appPassword) {
+    if (!config.username || !config.apiToken) {
       const status2 = { authenticated: false };
       this.handleResult(Result.ok(status2), context, () => {
         this.output.info("Not logged in");
@@ -34569,8 +34611,8 @@ class TokenCommand extends BaseCommand {
       }
       return credentialsResult;
     }
-    const { username, appPassword } = credentialsResult.value;
-    const token = Buffer.from(`${username}:${appPassword}`).toString("base64");
+    const { username, apiToken } = credentialsResult.value;
+    const token = Buffer.from(`${username}:${apiToken}`).toString("base64");
     this.output.text(token);
     return Result.ok(token);
   }
@@ -35188,6 +35230,221 @@ class CheckoutPRCommand extends BaseCommand {
   }
 }
 
+// src/commands/pr/diff.command.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+
+class DiffPRCommand extends BaseCommand {
+  prRepository;
+  contextService;
+  gitService;
+  name = "diff";
+  description = "View pull request diff";
+  constructor(prRepository, contextService, gitService, output) {
+    super(output);
+    this.prRepository = prRepository;
+    this.contextService = contextService;
+    this.gitService = gitService;
+  }
+  async execute(options, context) {
+    const repoContextResult = await this.contextService.requireRepoContext({
+      ...context.globalOptions,
+      ...options
+    });
+    if (!repoContextResult.success) {
+      this.handleResult(repoContextResult, context);
+      return repoContextResult;
+    }
+    const { workspace, repoSlug } = repoContextResult.value;
+    let prId;
+    if (options.id) {
+      prId = parseInt(options.id, 10);
+      if (isNaN(prId)) {
+        const error = new BBError({
+          code: 5002 /* VALIDATION_INVALID */,
+          message: "Invalid PR ID"
+        });
+        this.handleResult(Result.err(error), context);
+        return Result.err(error);
+      }
+    } else {
+      const currentBranchResult = await this.gitService.getCurrentBranch();
+      if (!currentBranchResult.success) {
+        const error = new BBError({
+          code: 5002 /* VALIDATION_INVALID */,
+          message: "No PR ID provided and could not determine current branch"
+        });
+        this.handleResult(Result.err(error), context);
+        return Result.err(error);
+      }
+      const currentBranch = currentBranchResult.value;
+      const prsResult = await this.prRepository.list(workspace, repoSlug, "OPEN", 100);
+      if (!prsResult.success) {
+        this.handleResult(prsResult, context);
+        return prsResult;
+      }
+      const pr = prsResult.value.values.find((p) => p.source.branch.name === currentBranch);
+      if (!pr) {
+        const error = new BBError({
+          code: 5002 /* VALIDATION_INVALID */,
+          message: `No open pull request found for branch "${currentBranch}"`
+        });
+        this.handleResult(Result.err(error), context);
+        return Result.err(error);
+      }
+      prId = pr.id;
+    }
+    if (options.web) {
+      const prResult = await this.prRepository.get(workspace, repoSlug, prId);
+      if (!prResult.success) {
+        this.handleResult(prResult, context);
+        return prResult;
+      }
+      const diffUrl = prResult.value.links.diff.href;
+      const webUrl = diffUrl.replace(/api\.bitbucket\.org\/2\.0\/repositories\/(.*?)\/pullrequests\/(\d+)\/diff/, "bitbucket.org/$1/pull-requests/$2/diff");
+      return this.openInBrowser(webUrl, context);
+    }
+    if (options.stat) {
+      return this.showStat(workspace, repoSlug, prId, context);
+    }
+    if (options.nameOnly) {
+      return this.showNameOnly(workspace, repoSlug, prId, context);
+    }
+    return this.showDiff(workspace, repoSlug, prId, options, context);
+  }
+  async openInBrowser(url, context) {
+    if (context.globalOptions.json) {
+      this.output.json({ url });
+      return Result.ok({ diff: url });
+    }
+    this.output.info(`Opening ${url} in your browser...`);
+    try {
+      const platform = process.platform;
+      let command;
+      if (platform === "darwin") {
+        command = `open "${url}"`;
+      } else if (platform === "win32") {
+        command = `start "" "${url}"`;
+      } else {
+        command = `xdg-open "${url}"`;
+      }
+      await execAsync(command);
+      return Result.ok({ diff: url });
+    } catch (error) {
+      const bbError = new BBError({
+        code: 3002 /* GIT_COMMAND_FAILED */,
+        message: "Failed to open browser",
+        cause: error instanceof Error ? error : undefined
+      });
+      this.handleResult(Result.err(bbError), context);
+      return Result.err(bbError);
+    }
+  }
+  async showStat(workspace, repoSlug, prId, context) {
+    const diffstatResult = await this.prRepository.getDiffstat(workspace, repoSlug, prId);
+    if (!diffstatResult.success) {
+      this.handleResult(diffstatResult, context);
+      return diffstatResult;
+    }
+    const diffstat = diffstatResult.value;
+    const files = diffstat.values.map((file) => {
+      const path = file.new?.path || file.old?.path || "unknown";
+      return {
+        path,
+        additions: file.lines_added,
+        deletions: file.lines_removed
+      };
+    });
+    const totalAdditions = files.reduce((sum, f) => sum + f.additions, 0);
+    const totalDeletions = files.reduce((sum, f) => sum + f.deletions, 0);
+    const filesChanged = files.length;
+    const result = {
+      stat: {
+        filesChanged,
+        insertions: totalAdditions,
+        deletions: totalDeletions,
+        files
+      }
+    };
+    this.handleResult(Result.ok(result), context, () => {
+      for (const file of files) {
+        const additions = file.additions > 0 ? source_default.green(`+${file.additions}`) : "";
+        const deletions = file.deletions > 0 ? source_default.red(`-${file.deletions}`) : "";
+        const stats = [additions, deletions].filter(Boolean).join(" ");
+        this.output.text(`${file.path} ${stats ? `| ${stats}` : ""}`);
+      }
+      this.output.text("");
+      const summary = [
+        `${filesChanged} file${filesChanged !== 1 ? "s" : ""} changed`,
+        totalAdditions > 0 ? source_default.green(`${totalAdditions} insertion${totalAdditions !== 1 ? "s" : ""}(+)`) : null,
+        totalDeletions > 0 ? source_default.red(`${totalDeletions} deletion${totalDeletions !== 1 ? "s" : ""}(-)`) : null
+      ].filter(Boolean).join(", ");
+      this.output.text(summary);
+    });
+    return Result.ok(result);
+  }
+  async showNameOnly(workspace, repoSlug, prId, context) {
+    const diffstatResult = await this.prRepository.getDiffstat(workspace, repoSlug, prId);
+    if (!diffstatResult.success) {
+      this.handleResult(diffstatResult, context);
+      return diffstatResult;
+    }
+    const diffstat = diffstatResult.value;
+    const fileNames = diffstat.values.map((file) => file.new?.path || file.old?.path || "unknown");
+    const result = {
+      diff: fileNames.join(`
+`)
+    };
+    this.handleResult(Result.ok(result), context, () => {
+      for (const fileName of fileNames) {
+        this.output.text(fileName);
+      }
+    });
+    return Result.ok(result);
+  }
+  async showDiff(workspace, repoSlug, prId, options, context) {
+    const diffResult = await this.prRepository.getDiff(workspace, repoSlug, prId);
+    if (!diffResult.success) {
+      this.handleResult(diffResult, context);
+      return diffResult;
+    }
+    const diff = diffResult.value;
+    const result = { diff };
+    this.handleResult(Result.ok(result), context, () => {
+      const shouldColorize = this.shouldColorize(options.color);
+      const colorizedDiff = shouldColorize ? this.colorizeDiff(diff) : diff;
+      this.output.text(colorizedDiff);
+    });
+    return Result.ok(result);
+  }
+  shouldColorize(colorOption) {
+    if (!colorOption || colorOption === "auto") {
+      return process.stdout.isTTY ?? false;
+    }
+    return colorOption === "always";
+  }
+  colorizeDiff(diff) {
+    const lines = diff.split(`
+`);
+    return lines.map((line) => {
+      if (line.startsWith("+") && !line.startsWith("+++")) {
+        return source_default.green(line);
+      } else if (line.startsWith("-") && !line.startsWith("---")) {
+        return source_default.red(line);
+      } else if (line.startsWith("@@")) {
+        return source_default.cyan(line);
+      } else if (line.startsWith("diff --git")) {
+        return source_default.bold(line);
+      } else if (line.startsWith("index ") || line.startsWith("---") || line.startsWith("+++")) {
+        return source_default.dim(line);
+      }
+      return line;
+    }).join(`
+`);
+  }
+}
+
 // src/types/config.ts
 var SETTABLE_CONFIG_KEYS = ["defaultWorkspace"];
 var READABLE_CONFIG_KEYS = ["username", "defaultWorkspace"];
@@ -35203,7 +35460,7 @@ class GetConfigCommand extends BaseCommand {
   configService;
   name = "get";
   description = "Get a configuration value";
-  static HIDDEN_KEYS = ["appPassword"];
+  static HIDDEN_KEYS = ["apiToken"];
   constructor(configService, output) {
     super(output);
     this.configService = configService;
@@ -35248,7 +35505,7 @@ class SetConfigCommand extends BaseCommand {
   configService;
   name = "set";
   description = "Set a configuration value";
-  static PROTECTED_KEYS = ["username", "appPassword"];
+  static PROTECTED_KEYS = ["username", "apiToken"];
   constructor(configService, output) {
     super(output);
     this.configService = configService;
@@ -35304,7 +35561,7 @@ class ListConfigCommand extends BaseCommand {
     const displayConfig = {
       username: config.username || "",
       defaultWorkspace: config.defaultWorkspace || "",
-      appPassword: config.appPassword ? "********" : ""
+      apiToken: config.apiToken ? "********" : ""
     };
     this.handleResult(Result.ok(displayConfig), context, (data) => {
       this.output.text(source_default.dim(`Config file: ${this.configService.getConfigPath()}`));
@@ -35490,6 +35747,13 @@ function bootstrap() {
     const output = container.resolve(ServiceTokens.OutputService);
     return new CheckoutPRCommand(prRepo, contextService, gitService, output);
   });
+  container.register(ServiceTokens.DiffPRCommand, () => {
+    const prRepo = container.resolve(ServiceTokens.PullRequestRepository);
+    const contextService = container.resolve(ServiceTokens.ContextService);
+    const gitService = container.resolve(ServiceTokens.GitService);
+    const output = container.resolve(ServiceTokens.OutputService);
+    return new DiffPRCommand(prRepo, contextService, gitService, output);
+  });
   container.register(ServiceTokens.GetConfigCommand, () => {
     const configService = container.resolve(ServiceTokens.ConfigService);
     const output = container.resolve(ServiceTokens.OutputService);
@@ -35540,7 +35804,7 @@ if (process.argv.includes("--get-yargs-completions") || process.env.COMP_LINE) {
     } else if (env2.prev === "repo") {
       completions.push("clone", "create", "list", "view", "delete");
     } else if (env2.prev === "pr") {
-      completions.push("create", "list", "view", "merge", "approve", "decline", "checkout");
+      completions.push("create", "list", "view", "merge", "approve", "decline", "checkout", "diff");
     } else if (env2.prev === "config") {
       completions.push("get", "set", "list");
     } else if (env2.prev === "completion") {
@@ -35571,108 +35835,179 @@ function withGlobalOptions(options, context) {
 var cli = new Command;
 cli.name("bb").description("A command-line interface for Bitbucket Cloud").version(pkg.version).option("--json", "Output as JSON").option("-w, --workspace <workspace>", "Specify workspace").option("-r, --repo <repo>", "Specify repository");
 var authCmd = new Command("auth").description("Authenticate with Bitbucket");
-authCmd.command("login").description("Authenticate with Bitbucket using an app password").option("-u, --username <username>", "Bitbucket username").option("-p, --password <password>", "Bitbucket app password").action(async (options) => {
+authCmd.command("login").description("Authenticate with Bitbucket using an API token").option("-u, --username <username>", "Bitbucket username").option("-p, --password <password>", "Bitbucket API token").action(async (options) => {
   const cmd = container.resolve(ServiceTokens.LoginCommand);
-  await cmd.execute(options, createContext(cli));
+  const result = await cmd.execute(options, createContext(cli));
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 authCmd.command("logout").description("Log out of Bitbucket").action(async () => {
   const cmd = container.resolve(ServiceTokens.LogoutCommand);
-  await cmd.execute(undefined, createContext(cli));
+  const result = await cmd.execute(undefined, createContext(cli));
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 authCmd.command("status").description("Show authentication status").action(async () => {
   const cmd = container.resolve(ServiceTokens.StatusCommand);
-  await cmd.execute(undefined, createContext(cli));
+  const result = await cmd.execute(undefined, createContext(cli));
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 authCmd.command("token").description("Print the current access token").action(async () => {
   const cmd = container.resolve(ServiceTokens.TokenCommand);
-  await cmd.execute(undefined, createContext(cli));
+  const result = await cmd.execute(undefined, createContext(cli));
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 cli.addCommand(authCmd);
 var repoCmd = new Command("repo").description("Manage repositories");
 repoCmd.command("clone <repository>").description("Clone a Bitbucket repository").option("-d, --directory <dir>", "Directory to clone into").action(async (repository, options) => {
   const cmd = container.resolve(ServiceTokens.CloneCommand);
-  await cmd.execute({ repository, ...options }, createContext(cli));
+  const result = await cmd.execute({ repository, ...options }, createContext(cli));
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 repoCmd.command("create <name>").description("Create a new repository").option("-d, --description <description>", "Repository description").option("--private", "Create a private repository (default)").option("--public", "Create a public repository").option("-p, --project <project>", "Project key").action(async (name, options) => {
   const cmd = container.resolve(ServiceTokens.CreateRepoCommand);
   const context = createContext(cli);
-  await cmd.execute(withGlobalOptions({ name, ...options }, context), context);
+  const result = await cmd.execute(withGlobalOptions({ name, ...options }, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 repoCmd.command("list").description("List repositories").option("--limit <number>", "Maximum number of repositories to list", "25").action(async (options) => {
   const cmd = container.resolve(ServiceTokens.ListReposCommand);
   const context = createContext(cli);
-  await cmd.execute(withGlobalOptions(options, context), context);
+  const result = await cmd.execute(withGlobalOptions(options, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 repoCmd.command("view [repository]").description("View repository details").action(async (repository, options) => {
   const cmd = container.resolve(ServiceTokens.ViewRepoCommand);
   const context = createContext(cli);
-  await cmd.execute(withGlobalOptions({ repository, ...options }, context), context);
+  const result = await cmd.execute(withGlobalOptions({ repository, ...options }, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 repoCmd.command("delete <repository>").description("Delete a repository").option("-y, --yes", "Skip confirmation prompt").action(async (repository, options) => {
   const cmd = container.resolve(ServiceTokens.DeleteRepoCommand);
   const context = createContext(cli);
-  await cmd.execute(withGlobalOptions({ repository, ...options }, context), context);
+  const result = await cmd.execute(withGlobalOptions({ repository, ...options }, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 cli.addCommand(repoCmd);
 var prCmd = new Command("pr").description("Manage pull requests");
 prCmd.command("create").description("Create a pull request").option("-t, --title <title>", "Pull request title").option("-b, --body <body>", "Pull request description").option("-s, --source <branch>", "Source branch (default: current branch)").option("-d, --destination <branch>", "Destination branch (default: main)").option("--close-source-branch", "Close source branch after merge").action(async (options) => {
   const cmd = container.resolve(ServiceTokens.CreatePRCommand);
   const context = createContext(cli);
-  await cmd.execute(withGlobalOptions(options, context), context);
+  const result = await cmd.execute(withGlobalOptions(options, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 prCmd.command("list").description("List pull requests").option("-s, --state <state>", "Filter by state (OPEN, MERGED, DECLINED, SUPERSEDED)", "OPEN").option("--limit <number>", "Maximum number of PRs to list", "25").action(async (options) => {
   const cmd = container.resolve(ServiceTokens.ListPRsCommand);
   const context = createContext(cli);
-  await cmd.execute(withGlobalOptions(options, context), context);
+  const result = await cmd.execute(withGlobalOptions(options, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 prCmd.command("view <id>").description("View pull request details").action(async (id, options) => {
   const cmd = container.resolve(ServiceTokens.ViewPRCommand);
   const context = createContext(cli);
-  await cmd.execute(withGlobalOptions({ id, ...options }, context), context);
+  const result = await cmd.execute(withGlobalOptions({ id, ...options }, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 prCmd.command("merge <id>").description("Merge a pull request").option("-m, --message <message>", "Merge commit message").option("--close-source-branch", "Delete the source branch after merging").option("--strategy <strategy>", "Merge strategy (merge_commit, squash, fast_forward)").action(async (id, options) => {
   const cmd = container.resolve(ServiceTokens.MergePRCommand);
   const context = createContext(cli);
-  await cmd.execute(withGlobalOptions({ id, ...options }, context), context);
+  const result = await cmd.execute(withGlobalOptions({ id, ...options }, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 prCmd.command("approve <id>").description("Approve a pull request").action(async (id, options) => {
   const cmd = container.resolve(ServiceTokens.ApprovePRCommand);
   const context = createContext(cli);
-  await cmd.execute(withGlobalOptions({ id, ...options }, context), context);
+  const result = await cmd.execute(withGlobalOptions({ id, ...options }, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 prCmd.command("decline <id>").description("Decline a pull request").action(async (id, options) => {
   const cmd = container.resolve(ServiceTokens.DeclinePRCommand);
   const context = createContext(cli);
-  await cmd.execute(withGlobalOptions({ id, ...options }, context), context);
+  const result = await cmd.execute(withGlobalOptions({ id, ...options }, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 prCmd.command("checkout <id>").description("Checkout a pull request locally").action(async (id, options) => {
   const cmd = container.resolve(ServiceTokens.CheckoutPRCommand);
   const context = createContext(cli);
-  await cmd.execute(withGlobalOptions({ id, ...options }, context), context);
+  const result = await cmd.execute(withGlobalOptions({ id, ...options }, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
+});
+prCmd.command("diff [id]").description("View pull request diff").option("--color <when>", "Colorize output (auto, always, never)", "auto").option("--name-only", "Show only names of changed files").option("--stat", "Show diffstat").option("-w, --web", "Open diff in web browser").action(async (id, options) => {
+  const cmd = container.resolve(ServiceTokens.DiffPRCommand);
+  const context = createContext(cli);
+  const result = await cmd.execute(withGlobalOptions({ id, ...options }, context), context);
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 cli.addCommand(prCmd);
 var configCmd = new Command("config").description("Manage configuration");
 configCmd.command("get <key>").description("Get a configuration value").action(async (key) => {
   const cmd = container.resolve(ServiceTokens.GetConfigCommand);
-  await cmd.execute({ key }, createContext(cli));
+  const result = await cmd.execute({ key }, createContext(cli));
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 configCmd.command("set <key> <value>").description("Set a configuration value").action(async (key, value) => {
   const cmd = container.resolve(ServiceTokens.SetConfigCommand);
-  await cmd.execute({ key, value }, createContext(cli));
+  const result = await cmd.execute({ key, value }, createContext(cli));
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 configCmd.command("list").description("List all configuration values").action(async () => {
   const cmd = container.resolve(ServiceTokens.ListConfigCommand);
-  await cmd.execute(undefined, createContext(cli));
+  const result = await cmd.execute(undefined, createContext(cli));
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 cli.addCommand(configCmd);
 var completionCmd = new Command("completion").description("Shell completion utilities");
 completionCmd.command("install").description("Install shell completions for bash, zsh, or fish").action(async () => {
   const cmd = container.resolve(ServiceTokens.InstallCompletionCommand);
-  await cmd.execute(undefined, createContext(cli));
+  const result = await cmd.execute(undefined, createContext(cli));
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 completionCmd.command("uninstall").description("Uninstall shell completions").action(async () => {
   const cmd = container.resolve(ServiceTokens.UninstallCompletionCommand);
-  await cmd.execute(undefined, createContext(cli));
+  const result = await cmd.execute(undefined, createContext(cli));
+  if (!result.success) {
+    process.exit(1);
+  }
 });
 cli.addCommand(completionCmd);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pilatos/bitbucket-cli",
-  "version": "0.3.1",
+  "version": "1.0.0",
   "description": "A command-line interface for Bitbucket Cloud",
   "author": "",
   "license": "MIT",