fix: add Glob.match() polyfill + improve auto-detect diagnostics (CLI-7T) (#487)

## Problem

When users run `sentry issue list` or `sentry issues` without explicit
org/project arguments, the auto-detection cascade fails with
`ContextError: Organization and project are required.` — 185 events
affecting 63 users
([CLI-7T](https://sentry.sentry.io/issues/7283798253/)).

**100% of events** are from the Node.js/npm distribution (`cli.runtime:
node`), and 46% use `--json` (AI agents/tool callers).

### Root cause

The `BunGlobPolyfill` class in the Node.js polyfill was missing the
`match()` method. When `anyGlobMatches()` in `project-root.ts` called
`new Bun.Glob(pattern).match(name)`, it threw a `TypeError` that was
silently swallowed by a bare `catch {}` block. This broke project root
detection for .NET (`*.sln`, `*.csproj`), Haskell (`*.cabal`), OCaml
(`*.opam`), and Nim (`*.nimble`) projects on the npm distribution.

While this bug is real, the primary cause for most users is simply
running the CLI from a directory without a Sentry-instrumented project
and with no env vars or config defaults set. The diagnostics and error
message improvements help these users find the right path forward.

## Fix

1. **Add `match()` to `BunGlobPolyfill`** — Uses `picomatch` (already
bundled via `tinyglobby`) with `{dot: true}` to match `Bun.Glob`
behavior.

2. **Add debug logging to `resolveAllTargets()`** — Each fallthrough
step (env vars → config defaults → DSN detection → directory inference)
now logs at debug level, visible with `--verbose`.

3. **Improve `ContextError` default alternatives** — Adds `sentry org
list` and `sentry project list <org>/` hints so users who don't know
their slugs have a clear next step.

## Tests

- 5 new tests for `Glob.match()` covering all `LANGUAGE_MARKER_GLOBS`
patterns, negative cases, directory path rejection, and consistency with
native `Bun.Glob.match()`.
- All existing tests pass. Typecheck and lint clean.

Fixes CLI-7T

Author: BYK

AGENTS.md

@@ -31,6 +31,7 @@
     "marked": "^15",
     "openai": "^6.22.0",
     "p-limit": "^7.2.0",
+    "picomatch": "^4.0.3",
     "pretty-ms": "^9.3.0",
     "qrcode-terminal": "^0.12.0",
     "semver": "^7.7.3",

bun.lock

@@ -5,6 +5,7 @@ import { execSync, spawn as nodeSpawn } from "node:child_process";
 import { access, readFile, writeFile } from "node:fs/promises";
 import { DatabaseSync } from "node:sqlite";
 
+import picomatch from "picomatch";
 import { compare as semverCompare } from "semver";
 import { glob } from "tinyglobby";
 import { uuidv7 } from "uuidv7";
@@ -175,9 +176,25 @@ const BunPolyfill = {
 
   Glob: class BunGlobPolyfill {
     private pattern: string;
+    /** Compiled matcher — created once at construction, reused on every match() call. */
+    private matcher: (input: string) => boolean;
+
     constructor(pattern: string) {
       this.pattern = pattern;
+      // Compile once with dot:true to match Bun.Glob behavior where
+      // `*` matches dotfiles by default (unlike picomatch defaults).
+      this.matcher = picomatch(pattern, { dot: true });
+    }
+
+    /**
+     * Synchronously test whether a string matches the glob pattern.
+     * Mirrors Bun.Glob.match() used by project-root detection for
+     * language marker globs (*.sln, *.csproj, etc.).
+     */
+    match(input: string): boolean {
+      return this.matcher(input);
     }
+
     async *scan(opts?: { cwd?: string }): AsyncIterable<string> {
       const results = await glob(this.pattern, {
         cwd: opts?.cwd || process.cwd(),

package.json

@@ -153,6 +153,8 @@ export class OutputError extends CliError {
 const DEFAULT_CONTEXT_ALTERNATIVES = [
   "Run from a directory with a Sentry-configured project",
   "Set SENTRY_ORG and SENTRY_PROJECT (or SENTRY_DSN) environment variables",
+  "Run 'sentry org list' to find your organization slug",
+  "Run 'sentry project list <org>/' to find project slugs",
 ] as const;
 
 /**

script/node-polyfills.ts

@@ -694,6 +694,8 @@ export async function resolveAllTargets(
     );
   }
 
+  log.debug("No explicit org/project flags provided, trying env vars");
+
   // 2. SENTRY_ORG / SENTRY_PROJECT environment variables
   const envVars = resolveFromEnvVars();
   if (envVars?.project) {
@@ -710,6 +712,8 @@ export async function resolveAllTargets(
     };
   }
 
+  log.debug("No SENTRY_ORG/SENTRY_PROJECT env vars, trying config defaults");
+
   // 3. Config defaults
   const defaultOrg = await getDefaultOrganization();
   const defaultProject = await getDefaultProject();
@@ -726,12 +730,23 @@ export async function resolveAllTargets(
     };
   }
 
+  log.debug("No config defaults set, trying DSN auto-detection");
+
   // 4. DSN auto-detection (may find multiple in monorepos)
   const detection = await detectAllDsns(cwd);
 
   if (detection.all.length === 0) {
+    log.debug(
+      "No DSNs found in source code or env files, trying directory name inference"
+    );
     // 5. Fallback: infer from directory name
-    return inferFromDirectoryName(cwd);
+    const result = await inferFromDirectoryName(cwd);
+    if (result.targets.length === 0) {
+      log.debug(
+        "Directory name inference found no matching projects — auto-detection failed"
+      );
+    }
+    return result;
   }
 
   return resolveDetectedDsns(detection);

src/lib/errors.ts

@@ -1,15 +1,17 @@
 /**
- * Node.js Polyfill Tests — Bun.spawn
+ * Node.js Polyfill Tests — Bun.spawn and Bun.Glob
  *
- * Tests the spawn logic used by the Node.js polyfill in script/node-polyfills.ts.
+ * Tests the spawn and glob logic used by the Node.js polyfill in
+ * script/node-polyfills.ts.
  *
  * We can't import the polyfill directly (it overwrites globalThis.Bun and has
- * side effects), so we reproduce the exact spawn implementation and verify its
- * contract: exited promise, stdin piping, env passthrough, and inherit stdio.
+ * side effects), so we reproduce the exact implementation and verify its
+ * contract.
  *
- * Fixes CLI-68: the original polyfill returned no `exited` property, causing
- * `await proc.exited` to resolve to `undefined` and the upgrade command to
- * throw "Setup failed with exit code undefined".
+ * Fixes CLI-68: spawn polyfill returned no `exited` property.
+ * Fixes CLI-7T: Glob polyfill was missing `match()`, causing silent
+ * failures in project-root detection for .NET/Haskell/OCaml/Nim projects
+ * on the Node.js distribution.
  */
 
 import { describe, expect, test } from "bun:test";
@@ -128,3 +130,99 @@ describe("spawn polyfill", () => {
     expect(() => proc.unref()).not.toThrow();
   });
 });
+
+/**
+ * Reproduces the exact Glob.match() logic from script/node-polyfills.ts.
+ * Kept in sync manually — if the polyfill changes, update this too.
+ */
+/**
+ * Lazy-loaded picomatch — imported once and cached.
+ * Uses require() to avoid top-level import of an untyped CJS module.
+ */
+let picomatch: any;
+function getPicomatch() {
+  if (!picomatch) {
+    picomatch = require("picomatch");
+  }
+  return picomatch;
+}
+
+class PolyfillGlob {
+  private readonly matcher: (input: string) => boolean;
+  constructor(pattern: string) {
+    this.matcher = getPicomatch()(pattern, { dot: true });
+  }
+  match(input: string): boolean {
+    return this.matcher(input);
+  }
+}
+
+describe("Glob polyfill match()", () => {
+  test("matches *.sln pattern", () => {
+    const glob = new PolyfillGlob("*.sln");
+    expect(glob.match("MyProject.sln")).toBe(true);
+    expect(glob.match("foo.sln")).toBe(true);
+    expect(glob.match("foo.txt")).toBe(false);
+    expect(glob.match("sln")).toBe(false);
+    expect(glob.match(".sln")).toBe(true);
+  });
+
+  test("matches *.csproj pattern", () => {
+    const glob = new PolyfillGlob("*.csproj");
+    expect(glob.match("MyApp.csproj")).toBe(true);
+    expect(glob.match("something.csproj")).toBe(true);
+    expect(glob.match("MyApp.fsproj")).toBe(false);
+    expect(glob.match("csproj")).toBe(false);
+  });
+
+  test("matches all LANGUAGE_MARKER_GLOBS patterns", () => {
+    // These are the glob patterns from src/lib/dsn/project-root.ts
+    const patterns = [
+      "*.sln",
+      "*.csproj",
+      "*.fsproj",
+      "*.vbproj",
+      "*.cabal",
+      "*.opam",
+      "*.nimble",
+    ];
+
+    const positives: Record<string, string> = {
+      "*.sln": "MyApp.sln",
+      "*.csproj": "Web.csproj",
+      "*.fsproj": "Lib.fsproj",
+      "*.vbproj": "Old.vbproj",
+      "*.cabal": "mylib.cabal",
+      "*.opam": "parser.opam",
+      "*.nimble": "tool.nimble",
+    };
+
+    for (const pattern of patterns) {
+      const glob = new PolyfillGlob(pattern);
+      const positive = positives[pattern];
+      expect(glob.match(positive!)).toBe(true);
+      // Should not match unrelated extensions
+      expect(glob.match("file.txt")).toBe(false);
+      expect(glob.match("file.js")).toBe(false);
+    }
+  });
+
+  test("does not match directory paths (glob is name-only)", () => {
+    const glob = new PolyfillGlob("*.sln");
+    // picomatch by default doesn't match path separators with *
+    expect(glob.match("dir/MyApp.sln")).toBe(false);
+  });
+
+  test("is consistent with Bun.Glob.match()", () => {
+    const patterns = ["*.sln", "*.csproj", "*.cabal"];
+    const inputs = ["App.sln", "foo.csproj", "bar.cabal", "nope.txt", ""];
+
+    for (const pattern of patterns) {
+      const polyfill = new PolyfillGlob(pattern);
+      const bunGlob = new Bun.Glob(pattern);
+      for (const input of inputs) {
+        expect(polyfill.match(input)).toBe(bunGlob.match(input));
+      }
+    }
+  });
+});