fix: clean up upgrade output and hide empty table headers

Clean up the ugly `cli upgrade` output and fix a systemic issue with
empty header rows in box-drawing tables across the codebase.

## Upgrade output

Before:
```
Binary: Installed to /home/byk/.local/bin/sentry
✓ Upgraded to  0.18.0-dev.1773836960
0.18.0-dev.1773794950 → 0.18.0-dev.1773836960

╭─────────┬─────────╮
│         │         │
├─────────┼─────────┤
│ Method  │ curl    │
│ Channel │ nightly │
╰─────────┴─────────╯
```

After:
```
✓ Upgraded to 0.18.0-dev.1773836960 (from 0.18.0-dev.1773794950)
  Method: curl · Channel: nightly
```

Changes:
- Replace metadata table with a compact muted inline line
- Remove redundant version arrow; fold "from" version into success line
- Add `--quiet` to `cli setup` subprocess to suppress leaked stdout

## Systemic table fix

`mdKvTable()` without a heading produces `| | |` empty header cells,
which rendered as an ugly empty bordered row in box-drawing tables.
This affected 12 call sites: auth status, issue/org/project details,
trace/span/log views, and more.

Fix: add `hideHeaders` option to `renderTextTable` and auto-detect
all-empty headers in `renderTableToken` to skip the header row while
still using it for column width measurement.

Author: BYK

src/commands/cli/upgrade.ts

@@ -379,6 +379,7 @@ async function runSetupOnNewBinary(opts: SetupOptions): Promise<void> {
   const args = [
     "cli",
     "setup",
+    "--quiet",
     "--method",
     method,
     "--channel",

src/lib/formatters/human.ts

@@ -2071,8 +2071,8 @@ const ACTION_DESCRIPTIONS: Record<UpgradeResult["action"], string> = {
 /**
  * Format upgrade result as rendered markdown.
  *
- * Produces a concise summary line with the action taken, version info,
- * and any warnings (e.g., PATH shadowing from old package manager install).
+ * Produces a concise summary: action line, compact metadata, and any
+ * warnings (e.g., PATH shadowing from old package manager install).
  * Designed as the `human` formatter for the `cli upgrade` command's
  * {@link OutputConfig}.
  *
@@ -2086,13 +2086,17 @@ export function formatUpgradeResult(data: UpgradeResult): string {
     case "upgraded":
     case "downgraded": {
       const verb = ACTION_DESCRIPTIONS[data.action];
-      const offlineNote = data.offline ? " (offline, from cache)" : "";
-      lines.push(
-        `${colorTag("green", "✓")} ${verb} to ${safeCodeSpan(data.targetVersion)}${escapeMarkdownInline(offlineNote)}`
-      );
-      if (data.currentVersion !== data.targetVersion) {
+      if (data.offline) {
+        lines.push(
+          `${colorTag("green", "✓")} ${verb} to ${safeCodeSpan(data.targetVersion)}${escapeMarkdownInline(" (offline, from cache)")}`
+        );
+      } else if (data.currentVersion !== data.targetVersion) {
+        lines.push(
+          `${colorTag("green", "✓")} ${verb} to ${safeCodeSpan(data.targetVersion)} ${escapeMarkdownInline(`(from ${data.currentVersion})`)}`
+        );
+      } else {
         lines.push(
-          `${escapeMarkdownInline(data.currentVersion)} → ${escapeMarkdownInline(data.targetVersion)}`
+          `${colorTag("green", "✓")} ${verb} to ${safeCodeSpan(data.targetVersion)}`
         );
       }
       break;
@@ -2123,19 +2127,13 @@ export function formatUpgradeResult(data: UpgradeResult): string {
     }
   }
 
-  // Metadata table — renders method, channel, and version info below the
-  // action line so diagnostics go to stdout (via the markdown pipeline)
-  // instead of cluttering stderr with repeated log.info() lines.
-  const kvRows: [string, string][] = [
-    ["Method", escapeMarkdownInline(data.method)],
-    ["Channel", escapeMarkdownInline(data.channel)],
-  ];
-  lines.push("");
-  lines.push(mdKvTable(kvRows));
+  // Compact metadata line instead of a full table — method and channel
+  // are lightweight diagnostics that don't warrant box-drawing borders.
+  const meta = `Method: ${data.method} · Channel: ${data.channel}`;
+  lines.push(`  ${colorTag("muted", escapeMarkdownInline(meta))}`);
 
   // Append warnings with ⚠ markers
   if (data.warnings && data.warnings.length > 0) {
-    lines.push("");
     for (const warning of data.warnings) {
       lines.push(`${colorTag("yellow", "⚠")} ${escapeMarkdownInline(warning)}`);
     }

src/lib/formatters/markdown.ts

@@ -554,6 +554,10 @@ function renderList(list: Tokens.List, depth = 0): string {
  *
  * Converts marked's `Tokens.Table` into headers + rows + alignments and
  * delegates to `renderTextTable()` for column fitting and box drawing.
+ *
+ * When all header cells are empty (e.g. from {@link mdKvTable} without a
+ * heading), the header row is hidden so the rendered table starts directly
+ * with data rows — no empty cells or separator line.
  */
 function renderTableToken(table: Tokens.Table): string {
   const headers = table.header.map((cell) => renderInline(cell.tokens));
@@ -571,7 +575,11 @@ function renderTableToken(table: Tokens.Table): string {
     return "left";
   });
 
-  return renderTextTable(headers, rows, { alignments });
+  // Hide the header row when all cells are empty — avoids rendering a
+  // visually empty bordered row above the data (common in mdKvTable output).
+  const hideHeaders = headers.every((h) => h.trim() === "");
+
+  return renderTextTable(headers, rows, { alignments, hideHeaders });
 }
 
 // ──────────────────────── Public API ─────────────────────────────────

src/lib/formatters/text-table.ts

@@ -56,6 +56,17 @@ export type TextTableOptions = {
   shrinkable?: boolean[];
   /** Truncate cells to one line with "\u2026" instead of wrapping. @default false */
   truncate?: boolean;
+  /**
+   * Hide the header row entirely (omit from rendered output).
+   *
+   * Headers are still used for column width measurement, but the rendered
+   * table starts directly with data rows. Useful for key-value tables where
+   * the markdown source requires empty header cells (`| | |`) to satisfy
+   * table syntax, but the visual output shouldn't show them.
+   *
+   * @default false
+   */
+  hideHeaders?: boolean;
   /**
    * Show horizontal separator lines between data rows.
    *
@@ -94,6 +105,7 @@ export function renderTextTable(
     minWidths = [],
     shrinkable = [],
     truncate = false,
+    hideHeaders = false,
     rowSeparator = false,
   } = options;
 
@@ -139,6 +151,7 @@ export function renderTextTable(
     border,
     cellPadding,
     headerSeparator,
+    hideHeaders,
     rowSeparator,
   });
 }
@@ -512,6 +525,8 @@ type GridParams = {
   border: BorderCharacters;
   cellPadding: number;
   headerSeparator: boolean;
+  /** Skip rendering the header row (allRows[0]) entirely. */
+  hideHeaders: boolean;
   /** Draw separator between data rows. `true` for plain, or ANSI color prefix string. */
   rowSeparator: boolean | string;
 };
@@ -562,6 +577,7 @@ function renderGrid(params: GridParams): string {
     border,
     cellPadding,
     headerSeparator,
+    hideHeaders,
     rowSeparator,
   } = params;
   const lines: string[] = [];
@@ -607,7 +623,11 @@ function renderGrid(params: GridParams): string {
     vert,
   };
 
-  for (let r = 0; r < allRows.length; r++) {
+  // When hideHeaders is set, skip allRows[0] (the header) and its separator.
+  // The header is still included in allRows for column width measurement.
+  const startRow = hideHeaders ? 1 : 0;
+
+  for (let r = startRow; r < allRows.length; r++) {
     const wrappedCells = allRows[r] ?? [];
     lines.push(...renderRowLines(wrappedCells, rowCtx));
 

test/commands/cli/upgrade.test.ts

@@ -66,8 +66,8 @@ function createMockContext(
     ...overrides.env,
   };
 
-  // Force plain output so formatUpgradeResult renders raw markdown tables
-  // (ASCII pipes) instead of Unicode box-drawing characters in TTY mode.
+  // Force plain output so formatUpgradeResult renders raw markdown
+  // instead of ANSI-styled output in TTY mode.
   const origPlain = process.env.SENTRY_PLAIN_OUTPUT;
   process.env.SENTRY_PLAIN_OUTPUT = "1";
 
@@ -281,7 +281,7 @@ describe("sentry cli upgrade", () => {
       );
 
       const combined = getOutput();
-      expect(combined).toContain("| curl |");
+      expect(combined).toContain("Method: curl");
       expect(combined).toContain(CLI_VERSION);
       expect(combined).toContain("You are already on the target version");
     });
@@ -375,7 +375,7 @@ describe("sentry cli upgrade", () => {
       );
 
       const combined = getOutput();
-      expect(combined).toContain("| brew |");
+      expect(combined).toContain("Method: brew");
       expect(combined).toContain("99.99.99");
       expect(combined).toContain("Run 'sentry cli upgrade' to update.");
     });
@@ -512,7 +512,7 @@ describe("sentry cli upgrade — nightly channel", () => {
       );
 
       const combined = getOutput();
-      expect(combined).toContain("| nightly |");
+      expect(combined).toContain("Channel: nightly");
     });
 
     test("'stable' positional sets channel to stable", async () => {
@@ -531,7 +531,7 @@ describe("sentry cli upgrade — nightly channel", () => {
       );
 
       const combined = getOutput();
-      expect(combined).toContain("| stable |");
+      expect(combined).toContain("Channel: stable");
     });
 
     test("without positional, uses persisted channel", async () => {
@@ -550,7 +550,7 @@ describe("sentry cli upgrade — nightly channel", () => {
       );
 
       const combined = getOutput();
-      expect(combined).toContain("| nightly |");
+      expect(combined).toContain("Channel: nightly");
     });
   });
 
@@ -605,7 +605,7 @@ describe("sentry cli upgrade — nightly channel", () => {
       );
 
       const combined = getOutput();
-      expect(combined).toContain("| nightly |");
+      expect(combined).toContain("Channel: nightly");
       expect(combined).toContain(CLI_VERSION);
       expect(combined).toContain("You are already on the target version");
     });
@@ -625,7 +625,7 @@ describe("sentry cli upgrade — nightly channel", () => {
       );
 
       const combined = getOutput();
-      expect(combined).toContain("| nightly |");
+      expect(combined).toContain("Channel: nightly");
       expect(combined).toContain("0.99.0-dev.9999999999");
       expect(combined).toContain("Run 'sentry cli upgrade' to update.");
     });
@@ -741,6 +741,7 @@ describe("sentry cli upgrade — curl full upgrade path (Bun.spawn spy)", () =>
     expect(setupCall).toBeDefined();
     expect(setupCall).toContain("cli");
     expect(setupCall).toContain("setup");
+    expect(setupCall).toContain("--quiet");
     expect(setupCall).toContain("--method");
     expect(setupCall).toContain("curl");
     expect(setupCall).toContain("--install");

test/lib/formatters/human.test.ts

@@ -756,7 +756,7 @@ describe("formatUpgradeResult", () => {
     }
   }
 
-  test("renders metadata table with method and channel", () => {
+  test("renders compact metadata line with method and channel", () => {
     withPlain(() => {
       const result = formatUpgradeResult({
         action: "upgraded",
@@ -766,12 +766,28 @@ describe("formatUpgradeResult", () => {
         method: "curl",
         forced: false,
       });
-      expect(result).toContain("| **Method** | curl |");
-      expect(result).toContain("| **Channel** | stable |");
+      expect(result).toContain("Method: curl");
+      expect(result).toContain("Channel: stable");
     });
   });
 
-  test("renders nightly channel in metadata table", () => {
+  test("includes from-version in upgraded action", () => {
+    withPlain(() => {
+      const result = formatUpgradeResult({
+        action: "upgraded",
+        currentVersion: "0.5.0",
+        targetVersion: "0.6.0",
+        channel: "stable",
+        method: "curl",
+        forced: false,
+      });
+      expect(result).toContain("Upgraded to");
+      expect(result).toContain("0.6.0");
+      expect(result).toContain("(from 0.5.0)");
+    });
+  });
+
+  test("renders nightly channel in metadata line", () => {
     withPlain(() => {
       const result = formatUpgradeResult({
         action: "checked",
@@ -781,12 +797,12 @@ describe("formatUpgradeResult", () => {
         method: "npm",
         forced: false,
       });
-      expect(result).toContain("| **Method** | npm |");
-      expect(result).toContain("| **Channel** | nightly |");
+      expect(result).toContain("Method: npm");
+      expect(result).toContain("Channel: nightly");
     });
   });
 
-  test("up-to-date action includes metadata table", () => {
+  test("up-to-date action includes compact metadata", () => {
     withPlain(() => {
       const result = formatUpgradeResult({
         action: "up-to-date",
@@ -797,8 +813,39 @@ describe("formatUpgradeResult", () => {
         forced: false,
       });
       expect(result).toContain("Already up to date");
-      expect(result).toContain("| **Method** | brew |");
-      expect(result).toContain("| **Channel** | stable |");
+      expect(result).toContain("Method: brew");
+      expect(result).toContain("Channel: stable");
+    });
+  });
+
+  test("offline upgrade shows offline note instead of from-version", () => {
+    withPlain(() => {
+      const result = formatUpgradeResult({
+        action: "upgraded",
+        currentVersion: "0.5.0",
+        targetVersion: "0.6.0",
+        channel: "stable",
+        method: "curl",
+        forced: false,
+        offline: true,
+      });
+      expect(result).toContain("(offline, from cache)");
+      expect(result).not.toContain("(from 0.5.0)");
+    });
+  });
+
+  test("does not include from-version when versions match", () => {
+    withPlain(() => {
+      const result = formatUpgradeResult({
+        action: "upgraded",
+        currentVersion: "0.5.0",
+        targetVersion: "0.5.0",
+        channel: "stable",
+        method: "curl",
+        forced: true,
+      });
+      expect(result).toContain("Upgraded to");
+      expect(result).not.toContain("(from");
     });
   });
 });

test/lib/formatters/markdown.test.ts

@@ -703,6 +703,40 @@ describe("renderMarkdown blocks (rendered mode)", () => {
     expect(stripAnsi(result)).toContain("1");
     expect(stripAnsi(result)).toContain("2");
   });
+
+  test("hides empty header row in rendered KV tables", () => {
+    // mdKvTable without heading produces `| | |` empty headers
+    const md = mdKvTable([
+      ["Method", "curl"],
+      ["Channel", "stable"],
+    ]);
+    const result = rendered(md);
+    const plain = stripAnsi(result);
+
+    // Data rows should be present
+    expect(plain).toContain("Method");
+    expect(plain).toContain("curl");
+    expect(plain).toContain("Channel");
+    expect(plain).toContain("stable");
+
+    // Count content rows (lines containing │ vertical border)
+    const contentLines = plain.split("\n").filter((l) => l.includes("\u2502"));
+    // Should have exactly 2 data rows, no empty header row
+    expect(contentLines).toHaveLength(2);
+  });
+
+  test("shows header row when headers are non-empty", () => {
+    const md = "| Key | Value |\n|---|---|\n| a | b |";
+    const result = rendered(md);
+    const plain = stripAnsi(result);
+
+    expect(plain).toContain("Key");
+    expect(plain).toContain("Value");
+
+    // Content rows: header + data = 3 minimum
+    const contentLines = plain.split("\n").filter((l) => l.includes("\u2502"));
+    expect(contentLines.length).toBeGreaterThanOrEqual(2);
+  });
 });
 
 // ---------------------------------------------------------------------------