azdo-cli 0.19.0-develop.710 → 0.19.0-develop.724

package/README.md

@@ -15,11 +15,11 @@ Azure DevOps CLI focused on work item read/write workflows.
 - Attach a local file to a work item, or remove a named attachment (`add-attachment`, `delete-attachment`)
 - Read/write rich-text fields as markdown (`get-md-field`, `set-md-field`)
 - Download images embedded in rich-text fields, optionally resized for LLM use (`get-item`/`get-md-field` `--download-images`, `--resize-images`)
-- Check branch pull request status, open PRs to `develop` (optionally pre-filled from a repository-defined template), update an existing PR's title or description (`pr update`), list PR comment threads for any PR (`--pr-number`), resolve/reopen threads, link/unlink work items, and add/remove required or optional reviewers — all from the CLI (`pr`)
+- Check branch pull request status, open PRs to `develop` (optionally pre-filled from a repository-defined template), update an existing PR's title or description (`pr update`), abandon or reactivate one (`pr abandon` / `pr reactivate`), list PR comment threads for any PR (`--pr-number`), resolve/reopen threads, link/unlink work items, and add/remove required or optional reviewers — all from the CLI (`pr`)
 - Feed long PR titles, descriptions and comment bodies from a file or a pipe instead of the shell (`--title-file`, `--description-file`, `--file`; `-` reads standard input)
 - Persist org/project/default fields in local config (`config`)
 - List all fields of a work item (`list-fields`)
-- Authenticate per Azure DevOps organization with `azdo auth login` — OAuth (Microsoft Entra) by default, or a Personal Access Token via `--use-pat` (or the `AZDO_PAT` env var). Credentials are stored in the OS credential store. Inspect with `azdo auth status`, remove with `azdo auth logout`. Diagnose auth problems with `azdo auth diagnose`. See [docs/authentication.md](docs/authentication.md).
+- Authenticate per Azure DevOps organization with `azdo auth login` — OAuth (Microsoft Entra) by default, or a Personal Access Token via `--use-pat` (or the `AZDO_PAT` env var). Credentials are stored in the OS credential store. Inspect with `azdo auth status`, remove with `azdo auth logout`. Diagnose auth problems with `azdo auth diagnose`. Print the credential the CLI itself would use, for API calls the CLI does not yet wrap, with `azdo auth token`. See [docs/authentication.md](docs/authentication.md).
 - Trace all HTTP requests to a local file with `--trace <filepath>` (sensitive headers and tokens are automatically redacted).
 
 ## Installation
@@ -102,6 +102,12 @@ cat body.md | azdo pr edit --pr-number 64 --description-file -   # "edit" is an
 azdo pr update --pr-number 64 --title "A real title" --json  # { pullRequestId, title, description, url, noop, updatedFields }
 # Re-running with the values it already has writes nothing and reports "noop": true.
 
+# Abandon a PR you opened by mistake — reversible, never prompts, nothing is deleted
+azdo pr abandon --pr-number 64        # "close" is an alias; it does NOT complete/merge the PR
+azdo pr reactivate --pr-number 64     # bring it back; --pr-number-less lookup searches abandoned PRs
+azdo pr abandon --pr-number 64 --json # { pullRequestId, title, status, previousStatus, url, noop }
+# Already abandoned? noop, exit 0, no write. Already completed? exit 1, no write.
+
 # Link/unlink a work item, add/remove reviewers
 azdo pr work-items link 1234 --pr-number 64
 azdo pr work-items unlink 1234 --pr-number 64

package/dist/{chunk-TY5KENBQ.js → chunk-K2CKMY72.js}

@@ -825,10 +825,18 @@ function entryFor(account) {
   return wrapUnavailable(() => new Entry(SERVICE, account));
 }
 var legacyUnsetNoticeEmitted = false;
+var noticesSuppressed = false;
+function suppressCredentialStoreNotices(suppressed) {
+  noticesSuppressed = suppressed;
+}
+function writeNotice(message) {
+  if (noticesSuppressed) return;
+  process.stderr.write(message);
+}
 function emitLegacyUnsetNoticeOnce() {
   if (legacyUnsetNoticeEmitted) return;
   legacyUnsetNoticeEmitted = true;
-  process.stderr.write(
+  writeNotice(
     'A legacy PAT exists in the OS vault from a previous azdo-cli version, but no "org" is set in config. Run `azdo auth --org <name>` to re-store it under the per-org key, then `azdo clear-pat` to remove the legacy slot.\n'
   );
 }
@@ -925,7 +933,7 @@ async function maybeMigrateLegacy(targetOrg) {
     backend: probeBackend(),
     masked_pat: maskedDisplay(legacy)
   });
-  process.stderr.write(`Migrated legacy PAT to org ${targetOrg}.
+  writeNotice(`Migrated legacy PAT to org ${targetOrg}.
 `);
   return legacy;
 }
@@ -990,7 +998,7 @@ async function deletePat(org) {
   }
   try {
     const { unlinkSync: unlinkSync2 } = await import("fs");
-    const { lockPath: lockPath2 } = await import("./oauth-token-refresh-DEDIDLNN.js");
+    const { lockPath: lockPath2 } = await import("./oauth-token-refresh-PXUQE5JE.js");
     unlinkSync2(lockPath2(org));
   } catch {
   }
@@ -1180,6 +1188,7 @@ function _resetInFlight() {
 export {
   CredentialStoreUnavailableError,
   CredentialMissingError,
+  CredentialRefreshError,
   appendAuthAuditEvent,
   readAuditEvents,
   SETTINGS,
@@ -1211,6 +1220,7 @@ export {
   refreshIfNeeded,
   _resetInFlight,
   probeBackend,
+  suppressCredentialStoreNotices,
   getPat,
   getStoredCredential,
   storePat,

package/dist/index.js

@@ -2,6 +2,7 @@
 import {
   AZDO_RESOURCE_ID,
   CredentialMissingError,
+  CredentialRefreshError,
   CredentialStoreUnavailableError,
   SETTINGS,
   appendAuthAuditEvent,
@@ -32,12 +33,13 @@ import {
   setOrgScopedValue,
   storeOAuthCredential,
   storePat,
+  suppressCredentialStoreNotices,
   tokenResponseToCredential,
   unsetConfigValue,
   unsetOrgScopedValue
-} from "./chunk-TY5KENBQ.js";
+} from "./chunk-K2CKMY72.js";
 
-// src/index.ts
+// src/program.ts
 import { Command as Command19 } from "commander";
 
 // src/version.ts
@@ -1165,28 +1167,28 @@ function findDotEnvPat(startDir = process.cwd()) {
   return null;
 }
 async function resolveAuthCredential(org) {
-  const envPat = process.env.AZDO_PAT;
-  if (envPat && envPat.length > 0) {
-    return { pat: envPat, source: "env", kind: "pat" };
-  }
-  const stored = await getStoredCredential(org);
-  if (stored !== null) {
-    if (stored.kind === "pat") {
-      return { pat: stored.token, source: "credential-store", kind: "pat" };
+  let cred;
+  try {
+    cred = await exportCredential(org);
+  } catch (err) {
+    if (err instanceof CredentialMissingError) {
+      return null;
     }
-    const fresh = await refreshIfNeeded(org, stored);
+    throw err;
+  }
+  if (cred.kind === "oauth") {
     return {
-      pat: fresh.accessToken,
+      pat: cred.token,
       source: "credential-store",
       kind: "oauth",
-      accountId: fresh.accountId
+      accountId: cred.accountId
     };
   }
-  const dotEnvPat = findDotEnvPat();
-  if (dotEnvPat !== null) {
-    return { pat: dotEnvPat, source: "env", kind: "pat" };
-  }
-  return null;
+  return {
+    pat: cred.token,
+    source: cred.source === "credential-store" ? "credential-store" : "env",
+    kind: "pat"
+  };
 }
 var lastResolvedCredential = null;
 async function requireAuthCredential(org) {
@@ -1351,6 +1353,32 @@ async function status() {
   }
   return { orgs: out };
 }
+async function exportCredential(org) {
+  const envPat = process.env.AZDO_PAT;
+  if (envPat && envPat.length > 0) {
+    return { kind: "pat", token: envPat, source: "env" };
+  }
+  const stored = await getStoredCredential(org);
+  if (stored === null) {
+    const dotEnvPat = findDotEnvPat();
+    if (dotEnvPat !== null) {
+      return { kind: "pat", token: dotEnvPat, source: "dotenv" };
+    }
+    throw new CredentialMissingError(org);
+  }
+  if (stored.kind === "pat") {
+    return { kind: "pat", token: stored.token, source: "credential-store" };
+  }
+  const fresh = await refreshIfNeeded(org, stored);
+  return {
+    kind: "oauth",
+    token: fresh.accessToken,
+    source: "credential-store",
+    accountId: fresh.accountId,
+    expiresAt: fresh.expiresAt,
+    scope: fresh.scope
+  };
+}
 
 // src/services/git-remote.ts
 import { execFileSync } from "child_process";
@@ -2364,6 +2392,73 @@ async function handleLogout(options, orgFromGlobal) {
     throw err;
   }
 }
+function describeCredentialSource(cred) {
+  switch (cred.source) {
+    case "env":
+      return "the AZDO_PAT environment variable";
+    case "dotenv":
+      return "the AZDO_PAT entry in a .env file";
+    default:
+      return `the OS credential store (${probeBackend()})`;
+  }
+}
+function describeExportedCredential(cred, org) {
+  const source = describeCredentialSource(cred);
+  if (cred.kind === "oauth") {
+    const expires = new Date(cred.expiresAt * 1e3).toISOString();
+    return `OAuth access token for org ${org} from ${source}; account ${cred.accountId}, expires ${expires}.
+Send it as: Authorization: Bearer <token>
+`;
+  }
+  return `PAT for org ${org} from ${source}.
+Send it as: Authorization: Basic base64(":<token>")  (curl: -u :<token>)
+`;
+}
+function reportTokenFailure(err) {
+  if (err instanceof CredentialStoreUnavailableError) {
+    process.stderr.write(`${err.message}
+`);
+    process.exitCode = 4;
+    return;
+  }
+  if (err instanceof CredentialMissingError || err instanceof CredentialRefreshError) {
+    process.stderr.write(`${err.message}
+`);
+    process.exitCode = 1;
+    return;
+  }
+  throw err;
+}
+async function handleToken(orgFromGlobal) {
+  const resolved = resolveOrg({ org: orgFromGlobal });
+  if (!resolved) {
+    process.stderr.write(`${formatResolutionError()}
+`);
+    process.exitCode = 3;
+    return;
+  }
+  const org = resolved.org;
+  const stderrIsTty = Boolean(process.stderr.isTTY);
+  suppressCredentialStoreNotices(!stderrIsTty);
+  let cred;
+  try {
+    cred = await exportCredential(org);
+  } catch (err) {
+    reportTokenFailure(err);
+    return;
+  }
+  appendAuthAuditEvent({
+    event: "auth.token",
+    org,
+    backend: probeBackend(),
+    ...cred.kind === "oauth" ? { accountId: cred.accountId } : {}
+  });
+  if (stderrIsTty) {
+    process.stderr.write(describeExportedCredential(cred, org));
+  }
+  process.stdout.write(`${cred.token}
+`);
+}
 function createAuthCommand() {
   const command = new Command3("auth");
   command.description(
@@ -2448,6 +2543,38 @@ Note: \`azdo auth\` (no subcommand) preserves the legacy PAT-prompt entry point;
     const globals = logoutCmd.optsWithGlobals();
     await handleLogout(options, globals.org);
   });
+  const tokenCmd = command.command("token").description(
+    "Print the credential the CLI uses for an org \u2014 a PAT or an OAuth access token \u2014 to stdout (for scripted API calls)"
+  ).option("--org <name>", "Azure DevOps organization (defaults: git remote -> config)");
+  tokenCmd.action(async () => {
+    const globals = tokenCmd.optsWithGlobals();
+    await handleToken(globals.org);
+  });
+  tokenCmd.addHelpText(
+    "after",
+    `
+stdout carries the token and nothing else, so it is safe to capture:
+
+  TOKEN=$(azdo auth token --org myorg)
+
+The token is whichever credential the CLI would use itself (AZDO_PAT, then the
+stored credential for the org, then a .env AZDO_PAT); an expired OAuth access
+token is refreshed first. Treat it as a password \u2014 it carries your full access.
+
+Azure DevOps needs a different header for each kind:
+
+  PAT               curl -u :"$TOKEN" https://dev.azure.com/myorg/_apis/projects
+  OAuth access tok  curl -H "Authorization: Bearer $TOKEN" https://dev.azure.com/myorg/_apis/projects
+
+When stderr is a terminal the command names the kind, source and expiry there;
+redirected or piped, stderr stays silent. There is deliberately no --json: use
+\`azdo auth status --json\` for machine-readable credential metadata, which never
+includes token material.
+
+Exit codes: 1 no stored credential (or a rejected OAuth refresh), 3 org could
+not be resolved, 4 OS credential store unavailable. stdout stays empty on all.
+`
+  );
   const diagnoseCmd = command.command("diagnose").description("Show auth type, credential source, org, and live connectivity test result").option("--org <name>", "Azure DevOps organization (overrides context resolution)").option("--project <name>", "Azure DevOps project (optional context)").option("--json", "emit JSON instead of human-readable text", false);
   diagnoseCmd.action(async (options) => {
     const globals = diagnoseCmd.optsWithGlobals();
@@ -4105,7 +4232,12 @@ function parsePositivePrNumber(raw) {
   const n = Number.parseInt(raw, 10);
   return Number.isFinite(n) && n > 0 ? n : null;
 }
-var PR_NUMBER_HELP = "target the pull request with this numeric id, instead of the current branch's PR. When omitted, the CLI auto-detects the pull request whose source branch equals refs/heads/<current branch> in the Azure DevOps repository identified by the origin remote; if zero or more than one open PR matches, the command fails with a message naming the searched branch.";
+function prNumberHelp(branchStatus = "active") {
+  const matched = branchStatus === "abandoned" ? "abandoned" : "open";
+  return `target the pull request with this numeric id, instead of the current branch's PR. When omitted, the CLI auto-detects the pull request whose source branch equals refs/heads/<current branch> in the Azure DevOps repository identified by the origin remote; if zero or more than one ${matched} PR matches, the command fails with a message naming the searched branch.`;
+}
+var PR_NUMBER_HELP = prNumberHelp();
+var PR_NUMBER_HELP_ABANDONED = prNumberHelp("abandoned");
 var PR_REPO_HELP = 'Azure DevOps repository name; defaults to the repository of the git "origin" remote';
 function configureUnwrappedHelp(command) {
   return command.configureHelp({ helpWidth: 1e3 });
@@ -4123,6 +4255,13 @@ function autoDetectMultiMatch(branch, ids) {
   const idList = ids.map((id) => `#${id}`).join(", ");
   return `Multiple open pull requests match branch ${branch}: ${idList}. Re-run with --pr-number to choose.`;
 }
+function abandonedAutoDetectZeroMatch(branch) {
+  return `No abandoned pull request matches branch ${branch}. Pass --pr-number to target a specific PR.`;
+}
+function abandonedAutoDetectMultiMatch(branch, ids) {
+  const idList = ids.map((id) => `#${id}`).join(", ");
+  return `Multiple abandoned pull requests match branch ${branch}: ${idList}. Re-run with --pr-number to choose.`;
+}
 function writeContractError(line) {
   process.stderr.write(`${line}
 `);
@@ -4595,11 +4734,14 @@ async function runPrUpdate(options) {
   }
   let context;
   try {
-    const target = await resolvePullRequestTarget(options);
+    const target = await resolvePullRequestTarget(options, {
+      onContextResolved: (resolved) => {
+        context = resolved;
+      }
+    });
     if (target === null) {
       return;
     }
-    context = target.context;
     const current = target.pullRequest;
     const { fields, updatedFields, requestedFields } = diffRequestedFields(requested, current);
     if (updatedFields.length === 0) {
@@ -4655,6 +4797,102 @@ function createPrUpdateCommand() {
   });
   return command;
 }
+var PR_STATUS_CHANGES = {
+  abandon: {
+    target: "abandoned",
+    search: "active",
+    verb: "abandoned",
+    applied: "Abandoned",
+    refusal: "abandoned"
+  },
+  reactivate: {
+    target: "active",
+    search: "abandoned",
+    verb: "active",
+    applied: "Reactivated",
+    refusal: "reactivated"
+  }
+};
+var COMPLETED_STATUS = "completed";
+async function runPrStatusChange(options, direction) {
+  const change = PR_STATUS_CHANGES[direction];
+  let context;
+  try {
+    const target = await resolvePullRequestTarget(options, {
+      branchStatus: change.search,
+      onContextResolved: (resolved) => {
+        context = resolved;
+      }
+    });
+    if (target === null) {
+      return;
+    }
+    const current = target.pullRequest;
+    if (current.status === COMPLETED_STATUS) {
+      writeError(
+        `Pull request #${current.id} is completed and cannot be ${change.refusal}. A completed pull request is final; revert it with a new pull request instead.`
+      );
+      return;
+    }
+    if (current.status === change.target) {
+      const noopResult = {
+        pullRequestId: current.id,
+        title: current.title,
+        status: current.status,
+        previousStatus: current.status,
+        url: current.url,
+        noop: true
+      };
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(noopResult, null, 2)}
+`);
+        return;
+      }
+      process.stdout.write(`Pull request #${current.id} is already ${change.verb}; nothing to do.
+`);
+      return;
+    }
+    const updated = await updatePullRequest(target.context, target.repo, target.pat, current.id, {
+      status: change.target
+    });
+    const result = {
+      pullRequestId: updated.id,
+      title: updated.title,
+      status: updated.status,
+      previousStatus: current.status,
+      url: updated.url,
+      noop: false
+    };
+    if (options.json) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+      return;
+    }
+    process.stdout.write(`${change.applied} pull request #${updated.id} (${updated.title}).
+${updated.url ?? "\u2014"}
+`);
+  } catch (err) {
+    handlePrCommandError(err, context, "write");
+  }
+}
+function createPrAbandonCommand() {
+  const command = new Command12("abandon");
+  withCommonPrOptions(configureUnwrappedHelp(command)).alias("close").description(
+    'Abandon a pull request (status: abandoned) \u2014 reversible with "azdo pr reactivate". This does NOT complete or merge the pull request; nothing is deleted and no confirmation is asked.'
+  ).option("--pr-number <N>", PR_NUMBER_HELP).option("--json", "output JSON").action(async (_options, command2) => {
+    await runPrStatusChange(mergedPrOptions(command2), "abandon");
+  });
+  return command;
+}
+function createPrReactivateCommand() {
+  const command = new Command12("reactivate");
+  withCommonPrOptions(configureUnwrappedHelp(command)).description(
+    "Reactivate an abandoned pull request (status: active). When --pr-number is omitted the current branch's single ABANDONED pull request is used, not the active one."
+  ).option("--pr-number <N>", PR_NUMBER_HELP_ABANDONED).option("--json", "output JSON").action(async (_options, command2) => {
+    await runPrStatusChange(mergedPrOptions(command2), "reactivate");
+  });
+  return command;
+}
 function createPrCommentsCommand() {
   const command = new Command12("comments");
   withCommonPrOptions(configureUnwrappedHelp(command)).description("List pull request comment threads for the current branch").option("--pr-number <N>", PR_NUMBER_HELP).option("--hide-resolved", "hide threads whose status is resolved / won't fix / closed / by design").option("--exclude-resolved", "alias of --hide-resolved: exclude resolved / won't fix / closed / by design threads").option("--code-related-only", "show only threads anchored to a file/line; omit general discussion threads").option("--exclude-system", "omit Azure DevOps system comments (branch updates, reviewer votes, build events)").option("--max-chars <N>", "truncate each comment body to N characters (0 = no limit, the default)").option("--thread <id>", "show only the thread with this numeric id; fails when the pull request has no such thread").option("--contains <text>", "show only threads holding a comment that contains this literal, case-sensitive substring (matched before --max-chars truncates)").option("--json", "output JSON").action(async (options) => {
@@ -4770,52 +5008,75 @@ function createPrCommentsCommand() {
   command.addCommand(createPrCommentsEditCommand());
   return command;
 }
-async function resolvePullRequestTarget(options) {
-  validateOrgProjectPair(options);
-  let explicitPrId = null;
-  if (options.prNumber !== void 0) {
-    explicitPrId = parsePositivePrNumber(options.prNumber);
-    if (explicitPrId === null) {
-      writeError(`Invalid --pr-number "${options.prNumber}"; expected a positive integer.`);
-      return null;
-    }
+function parseTargetPrNumber(options) {
+  if (options.prNumber === void 0) {
+    return "none";
   }
-  const resolved = await resolvePrCommandContext(options, { requireBranch: explicitPrId === null });
-  let pullRequest;
-  if (explicitPrId !== null) {
-    try {
-      pullRequest = await getPullRequestById(resolved.context, resolved.repo, resolved.pat, explicitPrId);
-    } catch (err) {
-      if (err instanceof Error && err.message.startsWith("NOT_FOUND")) {
-        writeError(`Pull request #${explicitPrId} not found in ${resolved.context.org}/${resolved.context.project}/${resolved.repo}.`, EXIT_NOT_FOUND);
-        return null;
-      }
-      throw err;
-    }
-  } else {
-    const pullRequests = await listPullRequests(resolved.context, resolved.repo, resolved.pat, resolved.branch, {
-      status: "active"
-    });
-    if (pullRequests.length === 0) {
-      writeContractError(autoDetectZeroMatch(resolved.branch));
-      return null;
-    }
-    if (pullRequests.length > 1) {
-      writeContractError(autoDetectMultiMatch(resolved.branch, pullRequests.map((pr) => pr.id)));
+  const parsed = parsePositivePrNumber(options.prNumber);
+  if (parsed === null) {
+    writeError(`Invalid --pr-number "${options.prNumber}"; expected a positive integer.`);
+    return "invalid";
+  }
+  return parsed;
+}
+async function fetchTargetById(resolved, prId) {
+  try {
+    return await getPullRequestById(resolved.context, resolved.repo, resolved.pat, prId);
+  } catch (err) {
+    if (err instanceof Error && err.message.startsWith("NOT_FOUND")) {
+      writeError(
+        `Pull request #${prId} not found in ${resolved.context.org}/${resolved.context.project}/${resolved.repo}.`,
+        EXIT_NOT_FOUND
+      );
       return null;
     }
-    pullRequest = pullRequests[0];
+    throw err;
+  }
+}
+async function findBranchPullRequest(resolved, branch, branchStatus) {
+  const pullRequests = await listPullRequests(resolved.context, resolved.repo, resolved.pat, branch, {
+    status: branchStatus
+  });
+  const abandoned = branchStatus === "abandoned";
+  if (pullRequests.length === 0) {
+    writeContractError(abandoned ? abandonedAutoDetectZeroMatch(branch) : autoDetectZeroMatch(branch));
+    return null;
+  }
+  if (pullRequests.length > 1) {
+    const ids = pullRequests.map((pr) => pr.id);
+    writeContractError(
+      abandoned ? abandonedAutoDetectMultiMatch(branch, ids) : autoDetectMultiMatch(branch, ids)
+    );
+    return null;
+  }
+  return pullRequests[0];
+}
+async function resolvePullRequestTarget(options, {
+  branchStatus = "active",
+  onContextResolved
+} = {}) {
+  validateOrgProjectPair(options);
+  const explicitPrId = parseTargetPrNumber(options);
+  if (explicitPrId === "invalid") {
+    return null;
+  }
+  const byBranch = explicitPrId === "none";
+  const resolved = await resolvePrCommandContext(options, { requireBranch: byBranch });
+  onContextResolved?.(resolved.context);
+  const pullRequest = byBranch ? await findBranchPullRequest(resolved, resolved.branch, branchStatus) : await fetchTargetById(resolved, explicitPrId);
+  if (pullRequest === null) {
+    return null;
   }
   return { context: resolved.context, repo: resolved.repo, pat: resolved.pat, pullRequest };
 }
-async function resolveThreadTarget(threadIdRaw, options) {
+async function resolveThreadTarget(threadIdRaw, options, { onContextResolved } = {}) {
   const threadId = parsePositivePrNumber(threadIdRaw);
   if (threadId === null) {
     validateOrgProjectPair(options);
     writeError(`Invalid thread id "${threadIdRaw}"; expected a positive integer.`);
     return null;
   }
-  const target = await resolvePullRequestTarget(options);
+  const target = await resolvePullRequestTarget(options, { onContextResolved });
   if (target === null) {
     return null;
   }
@@ -4824,11 +5085,14 @@ async function resolveThreadTarget(threadIdRaw, options) {
 async function runThreadStateChange(threadIdRaw, options, direction) {
   let context;
   try {
-    const target = await resolveThreadTarget(threadIdRaw, options);
+    const target = await resolveThreadTarget(threadIdRaw, options, {
+      onContextResolved: (resolved) => {
+        context = resolved;
+      }
+    });
     if (target === null) {
       return;
     }
-    context = target.context;
     const threads = await getPullRequestThreads(target.context, target.repo, target.pat, target.pullRequest.id);
     const thread = threads.find((t) => t.id === target.threadId);
     if (!thread) {
@@ -4901,11 +5165,14 @@ async function runCommentReply(threadIdRaw, text, options) {
     if (trimmedText === null) {
       return;
     }
-    const target = await resolveThreadTarget(threadIdRaw, options);
+    const target = await resolveThreadTarget(threadIdRaw, options, {
+      onContextResolved: (resolved) => {
+        context = resolved;
+      }
+    });
     if (target === null) {
       return;
     }
-    context = target.context;
     const threads = await getPullRequestThreads(target.context, target.repo, target.pat, target.pullRequest.id);
     const thread = threads.find((t) => t.id === target.threadId);
     if (!thread) {
@@ -4979,11 +5246,14 @@ async function runCommentAdd(text, options) {
       }
       status2 = match;
     }
-    const target = await resolvePullRequestTarget(options);
+    const target = await resolvePullRequestTarget(options, {
+      onContextResolved: (resolved) => {
+        context = resolved;
+      }
+    });
     if (target === null) {
       return;
     }
-    context = target.context;
     if (options.dryRun === true) {
       const dryResult = {
         pullRequestId: target.pullRequest.id,
@@ -5122,11 +5392,14 @@ async function runCommentEdit(threadIdRaw, text, options) {
         return;
       }
     }
-    const target = await resolveThreadTarget(threadIdRaw, options);
+    const target = await resolveThreadTarget(threadIdRaw, options, {
+      onContextResolved: (resolved) => {
+        context = resolved;
+      }
+    });
     if (target === null) {
       return;
     }
-    context = target.context;
     const thread = await fetchThreadForEdit(target);
     if (thread === null) {
       return;
@@ -5261,11 +5534,14 @@ async function runWorkItemLinkChange(workItemIdRaw, options, direction) {
       writeError(`Invalid work item id "${workItemIdRaw}"; expected a positive integer.`);
       return;
     }
-    const target = await resolvePullRequestTarget(options);
+    const target = await resolvePullRequestTarget(options, {
+      onContextResolved: (resolved) => {
+        context = resolved;
+      }
+    });
     if (target === null) {
       return;
     }
-    context = target.context;
     let outcome;
     try {
       outcome = direction === "link" ? await linkWorkItemToPullRequest(target.context, target.repo, target.pat, target.pullRequest.id, workItemId) : await unlinkWorkItemFromPullRequest(target.context, target.repo, target.pat, target.pullRequest.id, workItemId);
@@ -5320,11 +5596,14 @@ function createPrWorkItemsCommand() {
 async function runReviewerAdd(reviewer, options) {
   let context;
   try {
-    const target = await resolvePullRequestTarget(options);
+    const target = await resolvePullRequestTarget(options, {
+      onContextResolved: (resolved) => {
+        context = resolved;
+      }
+    });
     if (target === null) {
       return;
     }
-    context = target.context;
     let identity;
     try {
       identity = await resolveReviewerIdentity(target.context.org, target.pat, reviewer);
@@ -5375,11 +5654,14 @@ async function runReviewerAdd(reviewer, options) {
 async function runReviewerRemove(reviewer, options) {
   let context;
   try {
-    const target = await resolvePullRequestTarget(options);
+    const target = await resolvePullRequestTarget(options, {
+      onContextResolved: (resolved) => {
+        context = resolved;
+      }
+    });
     if (target === null) {
       return;
     }
-    context = target.context;
     let identity;
     try {
       identity = await resolveReviewerIdentity(target.context.org, target.pat, reviewer);
@@ -5435,6 +5717,8 @@ function createPrCommand() {
   command.addCommand(createPrStatusCommand());
   command.addCommand(createPrOpenCommand());
   command.addCommand(createPrUpdateCommand());
+  command.addCommand(createPrAbandonCommand());
+  command.addCommand(createPrReactivateCommand());
   command.addCommand(createPrCommentsCommand());
   command.addCommand(createPrCommentResolveCommand());
   command.addCommand(createPrCommentReopenCommand());
@@ -6930,6 +7214,18 @@ import os from "os";
 var THROTTLE_MS = 10 * 60 * 1e3;
 var FETCH_TIMEOUT_MS = 1500;
 var REGISTRY_URL = "https://registry.npmjs.org/azdo-cli/latest";
+var UPDATE_CHECK_EXEMPT_COMMANDS = /* @__PURE__ */ new Set(["auth token"]);
+function commandPathOf(command) {
+  const names = [];
+  for (let node = command; node !== null; node = node.parent) {
+    names.unshift(node.name());
+  }
+  return names;
+}
+function skipsUpdateCheck(commandPath) {
+  const withoutRoot = commandPath.slice(1);
+  return UPDATE_CHECK_EXEMPT_COMMANDS.has(withoutRoot.join(" "));
+}
 function getCachePath() {
   return path2.join(os.homedir(), ".azdo", "update-check.json");
 }
@@ -7027,6 +7323,49 @@ async function getUpdateNotice(opts) {
   }
 }
 
+// src/program.ts
+function createProgram() {
+  const program2 = new Command19();
+  program2.name("azdo").description("Azure DevOps CLI tool").version(version, "-v, --version");
+  program2.option("--no-update-check", "Skip the check for a newer published version");
+  program2.option("--trace <filepath>", "Append redacted HTTP request/response trace to a file (owner-read-only permissions)");
+  program2.addCommand(createGetItemCommand());
+  program2.addCommand(createAuthCommand());
+  program2.addCommand(createClearPatCommand());
+  program2.addCommand(createConfigCommand());
+  program2.addCommand(createSetStateCommand());
+  program2.addCommand(createAssignCommand());
+  program2.addCommand(createSetFieldCommand());
+  program2.addCommand(createGetMdFieldCommand());
+  program2.addCommand(createSetMdFieldCommand());
+  program2.addCommand(createUpsertCommand());
+  program2.addCommand(createListFieldsCommand());
+  program2.addCommand(createPrCommand());
+  program2.addCommand(createPipelineCommand());
+  program2.addCommand(createCommentsCommand());
+  program2.addCommand(createDownloadAttachmentCommand());
+  program2.addCommand(createAddAttachmentCommand());
+  program2.addCommand(createDeleteAttachmentCommand());
+  program2.addCommand(createRelationsCommand());
+  program2.showHelpAfterError();
+  program2.hook("preAction", () => {
+    const { trace } = program2.opts();
+    if (trace) {
+      initTraceWriter(trace);
+    }
+  });
+  program2.hook("postAction", async (_thisCommand, actionCommand) => {
+    if (skipsUpdateCheck(commandPathOf(actionCommand))) {
+      return;
+    }
+    const notice = await getUpdateNotice({ enabled: program2.opts().updateCheck });
+    if (notice) {
+      process.stderr.write(notice + "\n");
+    }
+  });
+  return program2;
+}
+
 // src/index.ts
 function exitOnEpipe(err) {
   if (err.code === "EPIPE") {
@@ -7036,41 +7375,7 @@ function exitOnEpipe(err) {
 }
 process.stdout.on("error", exitOnEpipe);
 process.stderr.on("error", exitOnEpipe);
-var program = new Command19();
-program.name("azdo").description("Azure DevOps CLI tool").version(version, "-v, --version");
-program.option("--no-update-check", "Skip the check for a newer published version");
-program.option("--trace <filepath>", "Append redacted HTTP request/response trace to a file (owner-read-only permissions)");
-program.addCommand(createGetItemCommand());
-program.addCommand(createAuthCommand());
-program.addCommand(createClearPatCommand());
-program.addCommand(createConfigCommand());
-program.addCommand(createSetStateCommand());
-program.addCommand(createAssignCommand());
-program.addCommand(createSetFieldCommand());
-program.addCommand(createGetMdFieldCommand());
-program.addCommand(createSetMdFieldCommand());
-program.addCommand(createUpsertCommand());
-program.addCommand(createListFieldsCommand());
-program.addCommand(createPrCommand());
-program.addCommand(createPipelineCommand());
-program.addCommand(createCommentsCommand());
-program.addCommand(createDownloadAttachmentCommand());
-program.addCommand(createAddAttachmentCommand());
-program.addCommand(createDeleteAttachmentCommand());
-program.addCommand(createRelationsCommand());
-program.showHelpAfterError();
-program.hook("preAction", () => {
-  const { trace } = program.opts();
-  if (trace) {
-    initTraceWriter(trace);
-  }
-});
-program.hook("postAction", async () => {
-  const notice = await getUpdateNotice({ enabled: program.opts().updateCheck });
-  if (notice) {
-    process.stderr.write(notice + "\n");
-  }
-});
+var program = createProgram();
 await program.parseAsync();
 if (process.argv.length <= 2) {
   program.help();

package/dist/{oauth-token-refresh-DEDIDLNN.js → oauth-token-refresh-PXUQE5JE.js}

@@ -5,7 +5,7 @@ import {
   lockPath,
   locksDir,
   refreshIfNeeded
-} from "./chunk-TY5KENBQ.js";
+} from "./chunk-K2CKMY72.js";
 export {
   _resetInFlight,
   classifyRefreshFailure,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azdo-cli",
-  "version": "0.19.0-develop.710",
+  "version": "0.19.0-develop.724",
   "description": "Azure DevOps CLI tool",
   "type": "module",
   "bin": {