azdo-cli 0.10.0-develop.386 → 0.10.0-develop.423

package/README.md

@@ -56,9 +56,18 @@ azdo comments add 12345 "Investigating the root cause now."
 # PR comment threads — list, filter, target by number, resolve or reopen
 azdo pr comments                        # active-branch PR
 azdo pr comments --pr-number 64         # any PR by number (skips branch lookup)
-azdo pr comments --pr-number 64 --hide-resolved
+azdo pr comments --pr-number 64 --hide-resolved      # or --exclude-resolved (alias)
+azdo pr comments --code-related-only    # only file/line-anchored threads
+azdo pr status                          # PR checks (status + branch policies) + code-comment counts
 azdo pr comment-resolve 17 --pr-number 64   # idempotent: exit 0 even when already resolved
 azdo pr comment-reopen 17  --pr-number 64
+
+# Pipelines — list, inspect runs, wait (exit code = result), start
+azdo pipeline list --filter ci
+azdo pipeline get-runs 12 --branch develop --limit 1
+azdo pipeline wait 3456                     # blocks; exit 0 success / non-zero failure / 124 timeout
+azdo pipeline get-run-detail 3456           # errors, failing tests, per-stage status
+azdo pipeline start 12 --branch develop --parameter env=staging
 ```
 
 ## Documentation

package/dist/index.js

@@ -31,7 +31,7 @@ import {
 } from "./chunk-C7RAZJHV.js";
 
 // src/index.ts
-import { Command as Command15 } from "commander";
+import { Command as Command16 } from "commander";
 
 // src/version.ts
 import { readFileSync } from "fs";
@@ -479,13 +479,13 @@ async function classifyDeviceTokenResponse(response) {
 async function pollForDeviceToken(deviceCode, oauthConfig, initialIntervalSec, expiresAtMs, deps) {
   const fetchFn = deps.fetch ?? fetch;
   const now = deps.now ?? (() => Date.now());
-  const sleep = deps.sleep ?? defaultSleep;
+  const sleep2 = deps.sleep ?? defaultSleep;
   let intervalSec = Math.max(MIN_INTERVAL_SEC, initialIntervalSec);
   for (; ; ) {
     if (now() >= expiresAtMs) {
       throw new DeviceCodeFlowError("expired_token", "device-code flow expired before authorisation completed");
     }
-    await sleep(intervalSec * 1e3);
+    await sleep2(intervalSec * 1e3);
     const body = new URLSearchParams({
       grant_type: "urn:ietf:params:oauth:grant-type:device_code",
       client_id: oauthConfig.clientId,
@@ -2652,6 +2652,21 @@ function buildPullRequestStatusesUrl(context, repo, prId) {
   url.searchParams.set("api-version", "7.1");
   return url;
 }
+function buildProjectUrl(context) {
+  const url = new URL(
+    `https://dev.azure.com/${encodeURIComponent(context.org)}/_apis/projects/${encodeURIComponent(context.project)}`
+  );
+  url.searchParams.set("api-version", "7.1");
+  return url;
+}
+function buildPolicyEvaluationsUrl(context, projectId, prId) {
+  const url = new URL(
+    `https://dev.azure.com/${encodeURIComponent(context.org)}/${encodeURIComponent(context.project)}/_apis/policy/evaluations`
+  );
+  url.searchParams.set("api-version", "7.1");
+  url.searchParams.set("artifactId", `vstfs:///CodeReview/CodeReviewId/${projectId}/${prId}`);
+  return url;
+}
 function mapPullRequest(repo, pullRequest) {
   return {
     id: pullRequest.pullRequestId,
@@ -2690,7 +2705,49 @@ function mapPullRequestCheck(status2) {
     targetUrl: status2.targetUrl ?? null,
     createdBy: status2.createdBy?.displayName ?? null,
     createdAt: status2.creationDate ?? null,
-    updatedAt: status2.updatedDate ?? null
+    updatedAt: status2.updatedDate ?? null,
+    source: "status"
+  };
+}
+function mapPolicyEvaluationState(status2) {
+  switch (status2) {
+    case "approved":
+      return "succeeded";
+    case "rejected":
+      return "failed";
+    case "running":
+    case "queued":
+      return "pending";
+    case "notApplicable":
+    case "notSet":
+    case void 0:
+      return null;
+    default:
+      return status2;
+  }
+}
+function mapPolicyEvaluationName(evaluation) {
+  const display = evaluation.configuration?.settings?.displayName?.trim() || evaluation.configuration?.type?.displayName?.trim();
+  if (display) {
+    return display;
+  }
+  return `Policy ${evaluation.configuration?.id ?? evaluation.evaluationId ?? "?"}`;
+}
+function mapPolicyEvaluationCheck(evaluation) {
+  const state = mapPolicyEvaluationState(evaluation.status);
+  if (state === null) {
+    return null;
+  }
+  return {
+    id: evaluation.configuration?.id ?? 0,
+    state,
+    name: mapPolicyEvaluationName(evaluation),
+    description: null,
+    targetUrl: null,
+    createdBy: null,
+    createdAt: null,
+    updatedAt: null,
+    source: "policy"
   };
 }
 function mapComment(comment) {
@@ -2776,6 +2833,21 @@ async function getPullRequestChecks(context, repo, cred, prId) {
   const data = await readJsonResponse(response);
   return data.value.map(mapPullRequestCheck).filter((check) => check !== null);
 }
+async function resolveProjectId(context, cred) {
+  const response = await fetchWithErrors(buildProjectUrl(context).toString(), {
+    headers: authHeaders(cred)
+  });
+  const data = await readJsonResponse(response);
+  return data.id;
+}
+async function getPullRequestPolicyEvaluations(context, cred, projectId, prId) {
+  const response = await fetchWithErrors(
+    buildPolicyEvaluationsUrl(context, projectId, prId).toString(),
+    { headers: authHeaders(cred) }
+  );
+  const data = await readJsonResponse(response);
+  return data.value.map(mapPolicyEvaluationCheck).filter((check) => check !== null);
+}
 async function openPullRequest(context, repo, cred, sourceBranch, title, description) {
   const existing = await listPullRequests(context, repo, cred, sourceBranch, {
     status: "active",
@@ -2884,7 +2956,10 @@ function handlePrCommandError(err, context, mode = "read") {
   }
   writeError(error.message);
 }
-function formatPullRequestChecks(checks) {
+function formatPullRequestChecks(checks, checksError) {
+  if (checksError) {
+    return [`Checks: unable to retrieve (${checksError})`];
+  }
   if (checks.length === 0) {
     return ["Checks: none reported by Azure DevOps"];
   }
@@ -2897,14 +2972,68 @@ function formatPullRequestChecks(checks) {
   }
   return lines;
 }
+function countCodeComments(threads) {
+  let open = 0;
+  let closed = 0;
+  for (const thread of threads) {
+    if (thread.threadContext === null) {
+      continue;
+    }
+    if (isThreadResolved(thread.status)) {
+      closed += 1;
+    } else {
+      open += 1;
+    }
+  }
+  return { open, closed };
+}
+function formatCodeCommentCounts(counts) {
+  return `Code comments: ${counts.open} open, ${counts.closed} closed`;
+}
 function formatPullRequestBlock(pullRequest) {
   return [
     `#${pullRequest.id} [${pullRequest.status}] ${pullRequest.title}`,
     `${formatBranchName(pullRequest.sourceRefName)} -> ${formatBranchName(pullRequest.targetRefName)}`,
     pullRequest.url ?? "\u2014",
-    ...formatPullRequestChecks(pullRequest.checks)
+    ...formatPullRequestChecks(pullRequest.checks, pullRequest.checksError),
+    formatCodeCommentCounts(pullRequest.codeCommentCounts)
   ].join("\n");
 }
+async function buildPullRequestStatusEntry(context, repo, cred, pullRequest, projectId) {
+  let statusChecks = [];
+  let statusOk = true;
+  try {
+    statusChecks = await getPullRequestChecks(context, repo, cred, pullRequest.id);
+  } catch {
+    statusOk = false;
+  }
+  let policyChecks = [];
+  let policyOk = true;
+  if (projectId === null) {
+    policyOk = false;
+  } else {
+    try {
+      policyChecks = await getPullRequestPolicyEvaluations(context, cred, projectId, pullRequest.id);
+    } catch {
+      policyOk = false;
+    }
+  }
+  let codeCommentCounts;
+  try {
+    const threads = await getPullRequestThreads(context, repo, cred, pullRequest.id);
+    codeCommentCounts = countCodeComments(threads);
+  } catch {
+    codeCommentCounts = { open: 0, closed: 0 };
+  }
+  const checks = [...statusChecks, ...policyChecks];
+  const checksError = checks.length === 0 && (!statusOk || !policyOk) ? "Azure DevOps request failed" : null;
+  return {
+    ...pullRequest,
+    checks,
+    codeCommentCounts,
+    checksError
+  };
+}
 function threadStatusLabel(status2) {
   return isThreadResolved(status2) ? "resolved" : status2;
 }
@@ -2941,11 +3070,16 @@ function createPrStatusCommand() {
       context = resolved.context;
       const branch = resolved.branch;
       const pullRequests = await listPullRequests(resolved.context, resolved.repo, resolved.pat, branch);
+      let projectId = null;
+      try {
+        projectId = await resolveProjectId(resolved.context, resolved.pat);
+      } catch {
+        projectId = null;
+      }
       const pullRequestsWithChecks = await Promise.all(
-        pullRequests.map(async (pullRequest) => ({
-          ...pullRequest,
-          checks: await getPullRequestChecks(resolved.context, resolved.repo, resolved.pat, pullRequest.id)
-        }))
+        pullRequests.map(
+          async (pullRequest) => buildPullRequestStatusEntry(resolved.context, resolved.repo, resolved.pat, pullRequest, projectId)
+        )
       );
       const result = { branch, repository: resolved.repo, pullRequests: pullRequestsWithChecks };
       if (options.json) {
@@ -3026,7 +3160,7 @@ ${result.pullRequest.url ?? "\u2014"}
 }
 function createPrCommentsCommand() {
   const command = new Command12("comments");
-  configureUnwrappedHelp(command).description("List pull request comment threads for the current branch").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--pr-number <N>", PR_NUMBER_HELP).option("--hide-resolved", "hide threads whose status is resolved / won't fix / closed / by design").option("--json", "output JSON").action(async (options) => {
+  configureUnwrappedHelp(command).description("List pull request comment threads for the current branch").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").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("--json", "output JSON").action(async (options) => {
     validateOrgProjectPair(options);
     let context;
     let explicitPrId = null;
@@ -3068,8 +3202,12 @@ function createPrCommentsCommand() {
         pullRequest = pullRequests[0];
         branchLabel = resolved.branch;
       }
+      const hideResolved = options.hideResolved === true || options.excludeResolved === true;
+      const codeRelatedOnly = options.codeRelatedOnly === true;
       const allThreads = await getPullRequestThreads(resolved.context, resolved.repo, resolved.pat, pullRequest.id);
-      const threads = options.hideResolved ? allThreads.filter((thread) => !isThreadResolved(thread.status)) : allThreads;
+      const threads = allThreads.filter(
+        (thread) => (!hideResolved || !isThreadResolved(thread.status)) && (!codeRelatedOnly || thread.threadContext !== null)
+      );
       const result = { branch: branchLabel, pullRequest, threads };
       if (options.json) {
         process.stdout.write(`${JSON.stringify(result, null, 2)}
@@ -3077,9 +3215,18 @@ function createPrCommentsCommand() {
         return;
       }
       if (threads.length === 0) {
-        if (options.hideResolved && allThreads.length > 0) {
-          process.stdout.write(`Pull request #${pullRequest.id} has no unresolved comment threads (${allThreads.length} resolved thread${allThreads.length === 1 ? "" : "s"} hidden by --hide-resolved).
-`);
+        if (allThreads.length > 0 && (hideResolved || codeRelatedOnly)) {
+          const filters = [];
+          if (codeRelatedOnly) {
+            filters.push("code-related");
+          }
+          if (hideResolved) {
+            filters.push("unresolved");
+          }
+          process.stdout.write(
+            `Pull request #${pullRequest.id} has no ${filters.join(" ")} comment threads (filtered from ${allThreads.length} thread${allThreads.length === 1 ? "" : "s"}).
+`
+          );
         } else {
           process.stdout.write(`Pull request #${pullRequest.id} has no comment threads.
 `);
@@ -3221,10 +3368,922 @@ function createPrCommand() {
   return command;
 }
 
-// src/commands/comments.ts
+// src/commands/pipeline.ts
 import { Command as Command13 } from "commander";
+
+// src/services/pipeline-client.ts
+var API_VERSION = "7.1";
+function orgProjectBase(context) {
+  return `https://dev.azure.com/${encodeURIComponent(context.org)}/${encodeURIComponent(context.project)}`;
+}
+function withApiVersion(url) {
+  url.searchParams.set("api-version", API_VERSION);
+  return url;
+}
+async function readJsonResponse2(response) {
+  if (!response.ok) {
+    throw new Error(`HTTP_${response.status}`);
+  }
+  return await response.json();
+}
+function mapPipeline(pipeline) {
+  return {
+    id: pipeline.id,
+    name: pipeline.name,
+    folder: pipeline.folder?.trim() ? pipeline.folder : null
+  };
+}
+function mapRunState(state) {
+  if (state === "inProgress" || state === "completed") {
+    return state;
+  }
+  return "unknown";
+}
+function mapRunResult(result) {
+  if (result === "succeeded" || result === "failed" || result === "canceled") {
+    return result;
+  }
+  if (result === "partiallySucceeded") {
+    return "failed";
+  }
+  return null;
+}
+function mapBuildState(status2) {
+  if (status2 === "completed") return "completed";
+  if (status2 === void 0 || status2 === "none") return "unknown";
+  return "inProgress";
+}
+function mapBuildSummary(build) {
+  return {
+    id: build.id,
+    name: build.buildNumber ?? null,
+    state: mapBuildState(build.status),
+    result: mapRunResult(build.result),
+    createdDate: build.queueTime ?? build.startTime ?? null,
+    finishedDate: build.finishTime ?? null,
+    sourceBranch: build.sourceBranch ?? null,
+    sourceCommit: build.sourceVersion ?? null
+  };
+}
+function normalizeRef(branch) {
+  return branch.startsWith("refs/") ? branch : `refs/heads/${branch}`;
+}
+async function getPipelineDefinitions(context, cred) {
+  const url = withApiVersion(new URL(`${orgProjectBase(context)}/_apis/pipelines`));
+  const response = await fetchWithErrors(url.toString(), { headers: authHeaders(cred) });
+  const data = await readJsonResponse2(response);
+  return data.value.map(mapPipeline);
+}
+var COMMIT_LOOKBACK = 200;
+async function getPipelineRuns(context, cred, query) {
+  const url = withApiVersion(new URL(`${orgProjectBase(context)}/_apis/build/builds`));
+  if (query.definitionId !== void 0) {
+    url.searchParams.set("definitions", String(query.definitionId));
+  }
+  if (query.prNumber !== void 0) {
+    url.searchParams.set("branchName", `refs/pull/${query.prNumber}/merge`);
+  } else if (query.branch) {
+    url.searchParams.set("branchName", normalizeRef(query.branch));
+  }
+  url.searchParams.set("queryOrder", "queueTimeDescending");
+  url.searchParams.set("$top", String(query.commit ? COMMIT_LOOKBACK : query.top));
+  const response = await fetchWithErrors(url.toString(), { headers: authHeaders(cred) });
+  const data = await readJsonResponse2(response);
+  let runs = data.value.map(mapBuildSummary);
+  if (query.commit) {
+    const needle = query.commit.toLowerCase();
+    runs = runs.filter((run) => run.sourceCommit?.toLowerCase().startsWith(needle));
+  }
+  return runs.slice(0, query.top);
+}
+async function runPipeline(context, cred, pipelineId, opts) {
+  const url = withApiVersion(
+    new URL(`${orgProjectBase(context)}/_apis/pipelines/${pipelineId}/runs`)
+  );
+  const body = {};
+  if (opts.branch) {
+    const refName = opts.branch.startsWith("refs/") ? opts.branch : `refs/heads/${opts.branch}`;
+    body.resources = { repositories: { self: { refName } } };
+  }
+  if (opts.parameters && Object.keys(opts.parameters).length > 0) {
+    body.templateParameters = opts.parameters;
+  }
+  const response = await fetchWithErrors(url.toString(), {
+    method: "POST",
+    headers: { ...authHeaders(cred), "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const data = await readJsonResponse2(response);
+  return {
+    id: data.id,
+    state: mapRunState(data.state),
+    webUrl: data._links?.web?.href ?? null
+  };
+}
+function buildUrl(context, buildId) {
+  return withApiVersion(new URL(`${orgProjectBase(context)}/_apis/build/builds/${buildId}`));
+}
+async function getBuild(context, cred, buildId) {
+  const response = await fetchWithErrors(buildUrl(context, buildId).toString(), {
+    headers: authHeaders(cred)
+  });
+  return readJsonResponse2(response);
+}
+async function getBuildStatus(context, cred, buildId) {
+  const build = await getBuild(context, cred, buildId);
+  return { state: mapBuildState(build.status), result: mapRunResult(build.result) };
+}
+async function getBuildTimeline(context, cred, buildId) {
+  const url = withApiVersion(
+    new URL(`${orgProjectBase(context)}/_apis/build/builds/${buildId}/timeline`)
+  );
+  const response = await fetchWithErrors(url.toString(), { headers: authHeaders(cred) });
+  const data = await readJsonResponse2(response);
+  const records = data.records ?? [];
+  const errors = [];
+  const stages = [];
+  const jobs = [];
+  const logSteps = /* @__PURE__ */ new Map();
+  for (const record of records) {
+    for (const issue of record.issues ?? []) {
+      if (issue.type === "error" && issue.message) {
+        errors.push({ message: issue.message, source: record.name ?? null });
+      }
+    }
+    if (record.name && record.log?.id !== void 0) {
+      logSteps.set(record.log.id, record.name);
+    }
+    if (!record.name) continue;
+    const status2 = {
+      name: record.name,
+      state: record.state ?? "unknown",
+      result: record.result ?? null
+    };
+    if (record.type === "Stage") {
+      stages.push(status2);
+    } else if (record.type === "Job") {
+      jobs.push({ startTime: record.startTime, status: status2 });
+    }
+  }
+  jobs.sort((a, b) => {
+    if (a.startTime === b.startTime) return 0;
+    if (a.startTime === void 0) return 1;
+    if (b.startTime === void 0) return -1;
+    return a.startTime < b.startTime ? -1 : 1;
+  });
+  return { errors, stages, jobs: jobs.map((j) => j.status), logSteps };
+}
+async function listTestRuns(context, cred, buildId) {
+  const url = withApiVersion(new URL(`${orgProjectBase(context)}/_apis/test/runs`));
+  url.searchParams.set("buildUri", `vstfs:///Build/Build/${buildId}`);
+  const response = await fetchWithErrors(url.toString(), { headers: authHeaders(cred) });
+  const data = await readJsonResponse2(response);
+  return data.value;
+}
+async function getTestSummary(context, cred, buildId) {
+  const testRuns = await listTestRuns(context, cred, buildId);
+  let total = 0;
+  let failed = 0;
+  for (const run of testRuns) {
+    const runTotal = run.totalTests ?? 0;
+    total += runTotal;
+    const passedOrSkipped = (run.passedTests ?? 0) + (run.notApplicableTests ?? 0) + (run.incompleteTests ?? 0);
+    failed += Math.max(0, runTotal - passedOrSkipped);
+  }
+  if (total === 0) {
+    return { present: false, total: 0, failed: 0, failedTests: [] };
+  }
+  return { present: true, total, failed, failedTests: [] };
+}
+var MAX_FAILED_TESTS = 50;
+async function getFailedTests(context, cred, buildId) {
+  const testRuns = await listTestRuns(context, cred, buildId);
+  const failed = [];
+  for (const testRun of testRuns) {
+    if (failed.length >= MAX_FAILED_TESTS) break;
+    const resultsUrl = withApiVersion(
+      new URL(`${orgProjectBase(context)}/_apis/test/runs/${testRun.id}/results`)
+    );
+    resultsUrl.searchParams.set("outcomes", "Failed");
+    resultsUrl.searchParams.set("$top", String(MAX_FAILED_TESTS - failed.length));
+    const resultsResponse = await fetchWithErrors(resultsUrl.toString(), {
+      headers: authHeaders(cred)
+    });
+    const resultsData = await readJsonResponse2(resultsResponse);
+    for (const result of resultsData.value) {
+      failed.push({
+        name: result.testCaseTitle ?? result.automatedTestName ?? "(unnamed test)",
+        errorMessage: result.errorMessage ?? null
+      });
+    }
+  }
+  return failed;
+}
+function secondsBetween(start, finish) {
+  if (!start || !finish) return null;
+  const ms = Date.parse(finish) - Date.parse(start);
+  return Number.isFinite(ms) ? Math.round(ms / 1e3) : null;
+}
+async function getRunDetail(context, cred, buildId) {
+  const build = await getBuild(context, cred, buildId);
+  let errors = [];
+  let stages = [];
+  let jobs = [];
+  let errorsAvailable = true;
+  try {
+    const timeline = await getBuildTimeline(context, cred, buildId);
+    errors = timeline.errors;
+    stages = timeline.stages;
+    jobs = timeline.jobs;
+  } catch {
+    errorsAvailable = false;
+  }
+  let tests = { present: false, total: 0, failed: 0, failedTests: [] };
+  let testsAvailable = true;
+  try {
+    tests = await getTestSummary(context, cred, buildId);
+    if (tests.failed > 0) {
+      try {
+        tests = { ...tests, failedTests: await getFailedTests(context, cred, buildId) };
+      } catch {
+      }
+    }
+  } catch {
+    testsAvailable = false;
+  }
+  return {
+    id: build.id,
+    name: build.buildNumber ?? null,
+    state: mapBuildState(build.status),
+    result: mapRunResult(build.result),
+    // createdDate is the queue time, matching the run-list mapping.
+    createdDate: build.queueTime ?? build.startTime ?? null,
+    startedDate: build.startTime ?? null,
+    finishedDate: build.finishTime ?? null,
+    durationSeconds: secondsBetween(build.startTime, build.finishTime),
+    reason: build.reason ?? null,
+    requestedFor: build.requestedFor?.displayName ?? null,
+    sourceBranch: build.sourceBranch ?? null,
+    sourceCommit: build.sourceVersion ?? null,
+    webUrl: build._links?.web?.href ?? null,
+    errors,
+    errorsAvailable,
+    stages,
+    jobs,
+    tests,
+    testsAvailable
+  };
+}
+async function getRunLogs(context, cred, buildId) {
+  const url = withApiVersion(
+    new URL(`${orgProjectBase(context)}/_apis/build/builds/${buildId}/logs`)
+  );
+  const response = await fetchWithErrors(url.toString(), { headers: authHeaders(cred) });
+  const data = await readJsonResponse2(response);
+  let logSteps = /* @__PURE__ */ new Map();
+  try {
+    logSteps = (await getBuildTimeline(context, cred, buildId)).logSteps;
+  } catch {
+  }
+  return data.value.map((log) => ({
+    id: log.id,
+    createdOn: log.createdOn ?? null,
+    lineCount: log.lineCount ?? null,
+    step: logSteps.get(log.id) ?? null
+  }));
+}
+async function getRunLog(context, cred, buildId, logId) {
+  const url = withApiVersion(
+    new URL(`${orgProjectBase(context)}/_apis/build/builds/${buildId}/logs/${logId}`)
+  );
+  const response = await fetchWithErrors(url.toString(), { headers: authHeaders(cred) });
+  if (!response.ok) {
+    throw new Error(`HTTP_${response.status}`);
+  }
+  return response.text();
+}
+
+// src/commands/pipeline.ts
+var EXIT_FAILED = 1;
+var EXIT_CANCELED = 2;
+var EXIT_TIMEOUT = 124;
 function writeError2(message) {
   process.stderr.write(`Error: ${message}
+`);
+  process.exitCode = 1;
+}
+function handlePipelineError(err, context) {
+  const error = err instanceof Error ? err : new Error(String(err));
+  if (error.message === "AUTH_FAILED") {
+    writeError2('Authentication failed. Check that your credential is valid and has the "Build (Read)" scope.');
+    return;
+  }
+  if (error.message === "PERMISSION_DENIED") {
+    writeError2(`Access denied. Your credential may lack pipeline permissions for project "${context?.project}".`);
+    return;
+  }
+  if (error.message === "NETWORK_ERROR") {
+    writeError2("Could not connect to Azure DevOps. Check your network connection.");
+    return;
+  }
+  if (error.message.startsWith("NOT_FOUND")) {
+    writeError2(`Resource not found in ${context?.org}/${context?.project}.`);
+    return;
+  }
+  if (error.message.startsWith("HTTP_")) {
+    writeError2(`Azure DevOps request failed with ${error.message}.`);
+    return;
+  }
+  writeError2(error.message);
+}
+function parsePositiveId(raw) {
+  if (!/^\d+$/.test(raw)) return null;
+  const n = Number.parseInt(raw, 10);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+function parseOptionalCount(value, flag) {
+  if (value === void 0) return void 0;
+  const parsed = parsePositiveId(value);
+  if (parsed === null) {
+    writeError2(`Invalid ${flag} "${value}"; expected a positive integer.`);
+    return null;
+  }
+  return parsed;
+}
+function formatBranchName2(refName) {
+  if (!refName) return "\u2014";
+  return refName.startsWith("refs/heads/") ? refName.slice("refs/heads/".length) : refName;
+}
+async function resolvePipelineContext(options) {
+  const context = resolveContext(options);
+  const cred = await requireAuthCredential(context.org);
+  return { context, cred };
+}
+function sleep(ms) {
+  return new Promise((resolve2) => {
+    setTimeout(resolve2, ms);
+  });
+}
+function formatTable(rows, rightAlign = /* @__PURE__ */ new Set()) {
+  const widths = [];
+  for (const row of rows) {
+    row.forEach((cell, i) => {
+      widths[i] = Math.max(widths[i] ?? 0, cell.length);
+    });
+  }
+  return rows.map(
+    (row) => row.map((cell, i) => rightAlign.has(i) ? cell.padStart(widths[i]) : cell.padEnd(widths[i])).join("  ").trimEnd()
+  ).join("\n");
+}
+function createPipelineListCommand() {
+  const command = new Command13("list");
+  command.description("List Azure DevOps pipeline definitions").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--filter <name>", "filter definitions by name (case-insensitive substring)").option("--json", "output JSON").action(async (options) => {
+    validateOrgProjectPair(options);
+    let context;
+    try {
+      const resolved = await resolvePipelineContext(options);
+      context = resolved.context;
+      let definitions = await getPipelineDefinitions(resolved.context, resolved.cred);
+      if (options.filter) {
+        const needle = options.filter.toLowerCase();
+        definitions = definitions.filter((d) => d.name.toLowerCase().includes(needle));
+      }
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(definitions, null, 2)}
+`);
+        return;
+      }
+      if (definitions.length === 0) {
+        process.stdout.write("No pipelines found.\n");
+        return;
+      }
+      const hasFolder = definitions.some((d) => d.folder);
+      const rows = definitions.map(
+        (d) => hasFolder ? [String(d.id), d.name, d.folder ?? ""] : [String(d.id), d.name]
+      );
+      process.stdout.write(`${formatTable(rows, /* @__PURE__ */ new Set([0]))}
+`);
+    } catch (err) {
+      handlePipelineError(err, context);
+    }
+  });
+  return command;
+}
+function runRow(run) {
+  const status2 = run.result ? `${run.state}/${run.result}` : run.state;
+  return [
+    String(run.id),
+    `[${status2}]`,
+    run.createdDate ?? "\u2014",
+    formatBranchName2(run.sourceBranch),
+    run.sourceCommit ? run.sourceCommit.slice(0, 8) : "\u2014"
+  ];
+}
+var COMMIT_SHA_PATTERN = /^[0-9a-f]{6,40}$/i;
+function parseGetRunsInputs(defIdRaw, options) {
+  let defId;
+  if (defIdRaw !== void 0) {
+    const parsed = parsePositiveId(defIdRaw);
+    if (parsed === null) {
+      writeError2(`Invalid definition id "${defIdRaw}"; expected a positive integer.`);
+      return null;
+    }
+    defId = parsed;
+  } else if (options.commit === void 0 && options.pr === void 0) {
+    writeError2("Definition id is required unless --commit or --pr is given.");
+    return null;
+  }
+  const limit = parseOptionalCount(options.limit, "--limit");
+  if (limit === null) return null;
+  const prNumber = parseOptionalCount(options.pr, "--pr");
+  if (prNumber === null) return null;
+  if (options.commit !== void 0 && !COMMIT_SHA_PATTERN.test(options.commit)) {
+    writeError2(`Invalid --commit "${options.commit}"; expected 6-40 hex characters.`);
+    return null;
+  }
+  if (options.branch !== void 0 && prNumber !== void 0) {
+    writeError2("Use either --branch or --pr, not both.");
+    return null;
+  }
+  return { defId, limit: limit ?? 10, prNumber };
+}
+function createPipelineGetRunsCommand() {
+  const command = new Command13("get-runs");
+  command.description("List recent runs for a pipeline definition (newest first)").argument("[def_id]", "pipeline definition id (optional with --commit or --pr)").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--limit <n>", "maximum number of runs to show (default 10)").option("--branch <branch>", "only show runs for this source branch").option("--commit <sha>", "only show runs that built this commit (full or abbreviated SHA)").option("--pr <number>", "only show runs for this pull request").option("--json", "output JSON").action(async (defIdRaw, options) => {
+    validateOrgProjectPair(options);
+    const inputs = parseGetRunsInputs(defIdRaw, options);
+    if (inputs === null) {
+      return;
+    }
+    let context;
+    try {
+      const resolved = await resolvePipelineContext(options);
+      context = resolved.context;
+      const runs = await getPipelineRuns(resolved.context, resolved.cred, {
+        definitionId: inputs.defId,
+        branch: options.branch,
+        prNumber: inputs.prNumber,
+        commit: options.commit,
+        top: inputs.limit
+      });
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(runs, null, 2)}
+`);
+        return;
+      }
+      if (runs.length === 0) {
+        process.stdout.write(
+          inputs.defId === void 0 ? "No runs found matching the filters.\n" : `No runs found for pipeline ${inputs.defId}.
+`
+        );
+        return;
+      }
+      process.stdout.write(`${formatTable(runs.map(runRow), /* @__PURE__ */ new Set([0]))}
+`);
+    } catch (err) {
+      handlePipelineError(err, context);
+    }
+  });
+  return command;
+}
+function applyWaitExitCode(result) {
+  if (result.timedOut) {
+    process.exitCode = EXIT_TIMEOUT;
+    return;
+  }
+  switch (result.result) {
+    case "succeeded":
+      return;
+    case "canceled":
+      process.exitCode = EXIT_CANCELED;
+      return;
+    case "failed":
+    default:
+      process.exitCode = EXIT_FAILED;
+  }
+}
+function createPipelineWaitCommand() {
+  const command = new Command13("wait");
+  command.description("Wait for a pipeline run to finish; exit code reflects the result (0 success, non-zero otherwise)").argument("<run_id>", "pipeline run id").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--timeout <seconds>", "maximum seconds to wait (default 1800)").option("--poll-interval <seconds>", "seconds between status checks (default 5)").option("--json", "output JSON").action(async (runIdRaw, options) => {
+    validateOrgProjectPair(options);
+    const runId = parsePositiveId(runIdRaw);
+    if (runId === null) {
+      writeError2(`Invalid run id "${runIdRaw}"; expected a positive integer.`);
+      return;
+    }
+    const timeoutSec = options.timeout === void 0 ? 1800 : Number(options.timeout);
+    const pollSec = options.pollInterval === void 0 ? 5 : Number(options.pollInterval);
+    if (!Number.isFinite(timeoutSec) || timeoutSec < 0) {
+      writeError2(`Invalid --timeout "${options.timeout}"; expected a non-negative number.`);
+      return;
+    }
+    if (!Number.isFinite(pollSec) || pollSec <= 0) {
+      writeError2(`Invalid --poll-interval "${options.pollInterval}"; expected a positive number.`);
+      return;
+    }
+    let context;
+    try {
+      const resolved = await resolvePipelineContext(options);
+      context = resolved.context;
+      const deadline = Date.now() + timeoutSec * 1e3;
+      let waitResult = null;
+      for (; ; ) {
+        const status2 = await getBuildStatus(resolved.context, resolved.cred, runId);
+        if (status2.state === "completed") {
+          waitResult = { id: runId, state: status2.state, result: status2.result, timedOut: false };
+          break;
+        }
+        if (Date.now() >= deadline) {
+          waitResult = { id: runId, state: status2.state, result: status2.result, timedOut: true };
+          break;
+        }
+        await sleep(pollSec * 1e3);
+      }
+      applyWaitExitCode(waitResult);
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(waitResult, null, 2)}
+`);
+        return;
+      }
+      if (waitResult.timedOut) {
+        process.stdout.write(`Run ${runId} did not finish within ${timeoutSec}s (still ${waitResult.state}).
+`);
+      } else {
+        process.stdout.write(`Run ${runId} finished: ${waitResult.result ?? waitResult.state}.
+`);
+      }
+    } catch (err) {
+      handlePipelineError(err, context);
+    }
+  });
+  return command;
+}
+function timelineRows(items, available) {
+  if (!available) {
+    return ["  unavailable"];
+  }
+  if (items.length === 0) {
+    return ["  (none)"];
+  }
+  return items.map((item) => `  - ${item.name} [${item.result ?? item.state}]`);
+}
+function formatDuration(totalSeconds) {
+  const h = Math.floor(totalSeconds / 3600);
+  const m = Math.floor(totalSeconds % 3600 / 60);
+  const s = totalSeconds % 60;
+  if (h > 0) return `${h}h${m}m${s}s`;
+  if (m > 0) return `${m}m${s}s`;
+  return `${s}s`;
+}
+function errorRows(detail) {
+  if (!detail.errorsAvailable) {
+    return ["  unavailable"];
+  }
+  if (detail.errors.length === 0) {
+    return ["  (none)"];
+  }
+  return detail.errors.map((error) => {
+    const source = error.source ? `[${error.source}] ` : "";
+    return `  - ${source}${error.message}`;
+  });
+}
+function failedTestRow(test) {
+  if (!test.errorMessage) {
+    return `  - ${test.name}`;
+  }
+  const firstLine = test.errorMessage.split("\n", 1)[0].trim();
+  return `  - ${test.name}: ${firstLine}`;
+}
+function testRows(detail) {
+  if (!detail.testsAvailable) {
+    return ["  unavailable"];
+  }
+  if (detail.tests.present) {
+    return [
+      `  ${detail.tests.failed} failing of ${detail.tests.total}`,
+      ...detail.tests.failedTests.map(failedTestRow)
+    ];
+  }
+  return ["  no tests present"];
+}
+function formatRunDetail(detail) {
+  const status2 = detail.result ? `${detail.state}/${detail.result}` : detail.state;
+  const name = detail.name ? ` ${detail.name}` : "";
+  const duration = detail.durationSeconds == null ? "\u2014" : formatDuration(detail.durationSeconds);
+  return [
+    `Run #${detail.id} [${status2}]${name}`,
+    `Queued: ${detail.createdDate ?? "\u2014"}    Started: ${detail.startedDate ?? "\u2014"}    Finished: ${detail.finishedDate ?? "\u2014"}`,
+    `Duration: ${duration}    Reason: ${detail.reason ?? "\u2014"}    Requested for: ${detail.requestedFor ?? "\u2014"}`,
+    `Branch: ${formatBranchName2(detail.sourceBranch)}    Commit: ${detail.sourceCommit ?? "unavailable"}`,
+    ...detail.webUrl ? [`Link: ${detail.webUrl}`] : [],
+    "",
+    "Stages:",
+    ...timelineRows(detail.stages, detail.errorsAvailable),
+    "",
+    "Jobs:",
+    ...timelineRows(detail.jobs, detail.errorsAvailable),
+    "",
+    "Errors:",
+    ...errorRows(detail),
+    "",
+    "Tests:",
+    ...testRows(detail)
+  ].join("\n");
+}
+function createPipelineGetRunDetailCommand() {
+  const command = new Command13("get-run-detail");
+  command.description("Show a detailed summary of a single pipeline run (errors, failing tests, stages)").argument("<run_id>", "pipeline run id").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--json", "output JSON").action(async (runIdRaw, options) => {
+    validateOrgProjectPair(options);
+    const runId = parsePositiveId(runIdRaw);
+    if (runId === null) {
+      writeError2(`Invalid run id "${runIdRaw}"; expected a positive integer.`);
+      return;
+    }
+    let context;
+    try {
+      const resolved = await resolvePipelineContext(options);
+      context = resolved.context;
+      const detail = await getRunDetail(resolved.context, resolved.cred, runId);
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(detail, null, 2)}
+`);
+        return;
+      }
+      process.stdout.write(`${formatRunDetail(detail)}
+`);
+    } catch (err) {
+      handlePipelineError(err, context);
+    }
+  });
+  return command;
+}
+function grepWithContext(lines, grep, context) {
+  const include = /* @__PURE__ */ new Set();
+  lines.forEach((line, i) => {
+    if (grep.test(line)) {
+      for (let j = Math.max(0, i - context); j <= Math.min(lines.length - 1, i + context); j++) {
+        include.add(j);
+      }
+    }
+  });
+  const selected = [];
+  let prev = -1;
+  for (const i of [...include].sort((a, b) => a - b)) {
+    if (selected.length > 0 && i > prev + 1) {
+      selected.push("--");
+    }
+    selected.push(lines[i]);
+    prev = i;
+  }
+  return selected;
+}
+function filterLogLines(content, grep, tail, context) {
+  let lines = content.split("\n");
+  if (lines.at(-1) === "") {
+    lines.pop();
+  }
+  if (grep) {
+    lines = context > 0 ? grepWithContext(lines, grep, context) : lines.filter((line) => grep.test(line));
+  }
+  if (tail !== void 0 && lines.length > tail) {
+    lines = lines.slice(-tail);
+  }
+  return lines;
+}
+function parseLogFilters(options) {
+  if (options.logId !== void 0 && options.step !== void 0) {
+    writeError2("Use either --log-id or --step, not both.");
+    return null;
+  }
+  const selectsSingleLog = options.logId !== void 0 || options.step !== void 0;
+  const slices = options.tail !== void 0 || options.grep !== void 0 || options.context !== void 0;
+  if (slices && !selectsSingleLog) {
+    writeError2("--tail, --grep, and --context require --log-id or --step.");
+    return null;
+  }
+  if (options.context !== void 0 && options.grep === void 0) {
+    writeError2("--context requires --grep.");
+    return null;
+  }
+  const tail = parseOptionalCount(options.tail, "--tail");
+  if (tail === null) return null;
+  const contextLines = parseOptionalCount(options.context, "--context");
+  if (contextLines === null) return null;
+  let grep;
+  if (options.grep !== void 0) {
+    try {
+      grep = new RegExp(options.grep);
+    } catch {
+      writeError2(`Invalid --grep "${options.grep}"; expected a valid regular expression.`);
+      return null;
+    }
+  }
+  return { tail, contextLines: contextLines ?? 0, grep };
+}
+function chooseStepLog(logs, step, runId) {
+  const needle = step.toLowerCase();
+  const matches = logs.filter((l) => l.step?.toLowerCase().includes(needle));
+  const exact = matches.filter((l) => l.step?.toLowerCase() === needle);
+  const chosen = exact.length === 1 ? exact : matches;
+  if (chosen.length === 0) {
+    writeError2(`No log matches step "${step}" in run ${runId}.`);
+    return null;
+  }
+  if (chosen.length > 1) {
+    const candidates = chosen.map((l) => `${l.id} (${l.step})`).join(", ");
+    writeError2(`Step "${step}" matches multiple logs: ${candidates}. Be more specific or use --log-id.`);
+    return null;
+  }
+  return chosen[0].id;
+}
+async function resolveRequestedLogId(resolved, runId, options) {
+  if (options.logId !== void 0) {
+    const parsed = parsePositiveId(options.logId);
+    if (parsed === null) {
+      writeError2(`Invalid --log-id "${options.logId}"; expected a positive integer.`);
+      return null;
+    }
+    return parsed;
+  }
+  if (options.step === void 0) {
+    return void 0;
+  }
+  const allLogs = await getRunLogs(resolved.context, resolved.cred, runId);
+  return chooseStepLog(allLogs, options.step, runId);
+}
+function printSingleLog(content, filters) {
+  if (filters.grep !== void 0 || filters.tail !== void 0) {
+    const lines = filterLogLines(content, filters.grep, filters.tail, filters.contextLines);
+    if (lines.length > 0) {
+      process.stdout.write(`${lines.join("\n")}
+`);
+    }
+    return;
+  }
+  process.stdout.write(content.endsWith("\n") ? content : `${content}
+`);
+}
+function createPipelineLogsCommand() {
+  const command = new Command13("logs");
+  command.description("List a pipeline run's logs, or print a specific log with --log-id").argument("<run_id>", "pipeline run id").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--log-id <id>", "print the content of this log id").option("--step <name>", "print the log of the step/job matching this name (case-insensitive substring)").option("--tail <n>", "with --log-id/--step, print only the last N lines").option("--grep <pattern>", "with --log-id/--step, print only lines matching this regular expression").option("--context <n>", "with --grep, also print N lines around each match (grep -C)").option("--json", "output JSON").action(async (runIdRaw, options) => {
+    validateOrgProjectPair(options);
+    const runId = parsePositiveId(runIdRaw);
+    if (runId === null) {
+      writeError2(`Invalid run id "${runIdRaw}"; expected a positive integer.`);
+      return;
+    }
+    const filters = parseLogFilters(options);
+    if (filters === null) {
+      return;
+    }
+    let context;
+    try {
+      const resolved = await resolvePipelineContext(options);
+      context = resolved.context;
+      const logId = await resolveRequestedLogId(resolved, runId, options);
+      if (logId === null) {
+        return;
+      }
+      if (logId !== void 0) {
+        const content = await getRunLog(resolved.context, resolved.cred, runId, logId);
+        printSingleLog(content, filters);
+        return;
+      }
+      const logs = await getRunLogs(resolved.context, resolved.cred, runId);
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(logs, null, 2)}
+`);
+        return;
+      }
+      if (logs.length === 0) {
+        process.stdout.write(`No logs found for run ${runId}.
+`);
+        return;
+      }
+      const rows = logs.map((l) => [
+        String(l.id),
+        l.createdOn ?? "\u2014",
+        l.lineCount == null ? "" : `${l.lineCount} lines`,
+        l.step ?? ""
+      ]);
+      process.stdout.write(`${formatTable(rows, /* @__PURE__ */ new Set([0]))}
+`);
+    } catch (err) {
+      handlePipelineError(err, context);
+    }
+  });
+  return command;
+}
+function createPipelineTestsCommand() {
+  const command = new Command13("tests");
+  command.description("Show a run's test results: summary plus failing tests by name (no log grepping needed)").argument("<run_id>", "pipeline run id").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--failed", "list only the failing tests").option("--json", "output JSON").action(async (runIdRaw, options) => {
+    validateOrgProjectPair(options);
+    const runId = parsePositiveId(runIdRaw);
+    if (runId === null) {
+      writeError2(`Invalid run id "${runIdRaw}"; expected a positive integer.`);
+      return;
+    }
+    let context;
+    try {
+      const resolved = await resolvePipelineContext(options);
+      context = resolved.context;
+      const summary = await getTestSummary(resolved.context, resolved.cred, runId);
+      const failedTests = summary.failed > 0 ? await getFailedTests(resolved.context, resolved.cred, runId) : [];
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify({ ...summary, failedTests }, null, 2)}
+`);
+        return;
+      }
+      if (!summary.present) {
+        process.stdout.write(`No test results published for run ${runId}.
+`);
+        return;
+      }
+      if (!options.failed) {
+        process.stdout.write(`Run #${runId}: ${summary.failed} failing of ${summary.total} tests
+`);
+      }
+      if (failedTests.length > 0) {
+        process.stdout.write(`${failedTests.map(failedTestRow).join("\n")}
+`);
+      } else if (options.failed) {
+        process.stdout.write("No failing tests.\n");
+      }
+    } catch (err) {
+      handlePipelineError(err, context);
+    }
+  });
+  return command;
+}
+function parseParameters(values) {
+  const result = {};
+  for (const entry of values ?? []) {
+    const eq = entry.indexOf("=");
+    if (eq <= 0) {
+      return null;
+    }
+    const key = entry.slice(0, eq);
+    const value = entry.slice(eq + 1);
+    result[key] = value;
+  }
+  return result;
+}
+function collectParameter(value, previous) {
+  return previous.concat([value]);
+}
+function createPipelineStartCommand() {
+  const command = new Command13("start");
+  command.description("Queue a new run of a pipeline definition").argument("<def_id>", "pipeline definition id").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--branch <branch>", "branch to run against (default: pipeline default branch)").option("--parameter <key=value>", "template parameter (repeatable)", collectParameter, []).option("--json", "output JSON").action(async (defIdRaw, options) => {
+    validateOrgProjectPair(options);
+    const defId = parsePositiveId(defIdRaw);
+    if (defId === null) {
+      writeError2(`Invalid definition id "${defIdRaw}"; expected a positive integer.`);
+      return;
+    }
+    const parameters = parseParameters(options.parameter);
+    if (parameters === null) {
+      writeError2("Invalid --parameter; expected key=value.");
+      return;
+    }
+    let context;
+    try {
+      const resolved = await resolvePipelineContext(options);
+      context = resolved.context;
+      const result = await runPipeline(resolved.context, resolved.cred, defId, {
+        branch: options.branch,
+        parameters
+      });
+      if (options.json) {
+        process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+        return;
+      }
+      process.stdout.write(`Queued run #${result.id} [${result.state}]
+${result.webUrl ?? "\u2014"}
+`);
+    } catch (err) {
+      handlePipelineError(err, context);
+    }
+  });
+  return command;
+}
+function createPipelineCommand() {
+  const command = new Command13("pipeline");
+  command.description("Manage Azure DevOps pipelines");
+  command.addCommand(createPipelineListCommand());
+  command.addCommand(createPipelineGetRunsCommand());
+  command.addCommand(createPipelineWaitCommand());
+  command.addCommand(createPipelineGetRunDetailCommand());
+  command.addCommand(createPipelineLogsCommand());
+  command.addCommand(createPipelineTestsCommand());
+  command.addCommand(createPipelineStartCommand());
+  return command;
+}
+
+// src/commands/comments.ts
+import { Command as Command14 } from "commander";
+function writeError3(message) {
+  process.stderr.write(`Error: ${message}
 `);
   process.exit(1);
 }
@@ -3242,7 +4301,7 @@ function formatComments(result, convertMarkdown) {
   return lines.join("\n");
 }
 function createCommentsListCommand() {
-  const command = new Command13("list");
+  const command = new Command14("list");
   command.description("List visible comments for a work item").argument("<id>", "work item ID").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--json", "output JSON").option("--markdown", "convert HTML comment bodies to markdown").action(async (idStr, options) => {
     validateOrgProjectPair(options);
     const id = parseWorkItemId(idStr);
@@ -3270,12 +4329,12 @@ function createCommentsListCommand() {
   return command;
 }
 function createCommentsAddCommand() {
-  const command = new Command13("add");
+  const command = new Command14("add");
   command.description("Add a comment to a work item").argument("<id>", "work item ID").argument("<text>", "comment text").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--json", "output JSON").option("--markdown", "post comment as markdown").action(async (idStr, text, options) => {
     validateOrgProjectPair(options);
     const id = parseWorkItemId(idStr);
     if (text.trim() === "") {
-      writeError2("Comment text must be a non-empty string.");
+      writeError3("Comment text must be a non-empty string.");
     }
     let context;
     try {
@@ -3297,7 +4356,7 @@ function createCommentsAddCommand() {
   return command;
 }
 function createCommentsCommand() {
-  const command = new Command13("comments");
+  const command = new Command14("comments");
   command.description("Manage Azure DevOps work item comments");
   command.addCommand(createCommentsListCommand());
   command.addCommand(createCommentsAddCommand());
@@ -3305,12 +4364,12 @@ function createCommentsCommand() {
 }
 
 // src/commands/download-attachment.ts
-import { Command as Command14 } from "commander";
+import { Command as Command15 } from "commander";
 import { writeFile as writeFile2 } from "fs/promises";
 import { existsSync as existsSync5 } from "fs";
 import { join as join3 } from "path";
 function createDownloadAttachmentCommand() {
-  const command = new Command14("download-attachment");
+  const command = new Command15("download-attachment");
   command.description("Download an attachment from an Azure DevOps work item").argument("<id>", "work item ID").argument("<filename>", "name of the attachment to download").option("--org <org>", "Azure DevOps organization").option("--project <project>", "Azure DevOps project").option("--output <dir>", "target directory for the downloaded file").action(
     async (idStr, filename, options) => {
       const id = parseWorkItemId(idStr);
@@ -3456,7 +4515,15 @@ async function getUpdateNotice(opts) {
 }
 
 // src/index.ts
-var program = new Command15();
+function exitOnEpipe(err) {
+  if (err.code === "EPIPE") {
+    process.exit(0);
+  }
+  throw err;
+}
+process.stdout.on("error", exitOnEpipe);
+process.stderr.on("error", exitOnEpipe);
+var program = new Command16();
 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.addCommand(createGetItemCommand());
@@ -3471,6 +4538,7 @@ program.addCommand(createSetMdFieldCommand());
 program.addCommand(createUpsertCommand());
 program.addCommand(createListFieldsCommand());
 program.addCommand(createPrCommand());
+program.addCommand(createPipelineCommand());
 program.addCommand(createCommentsCommand());
 program.addCommand(createDownloadAttachmentCommand());
 program.showHelpAfterError();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "azdo-cli",
-  "version": "0.10.0-develop.386",
+  "version": "0.10.0-develop.423",
   "description": "Azure DevOps CLI tool",
   "type": "module",
   "bin": {