fix(issue-list): auto-correct AND and reject OR in --query to prevent 400

Sentry search implicitly ANDs space-separated terms, so explicit AND
operators have identical semantics. Strip them with a log.warn() nudge
instead of letting the API reject the query with 400 Bad Request.

OR operators have genuinely different semantics (union vs intersection)
that can't be silently approximated, so throw a helpful ValidationError
with actionable alternatives (separate queries, wildcards, docs link).

Resolves CLI-BM, CLI-97, CLI-7B (300+ affected users).

Author: BYK

src/commands/issue/list.ts

@@ -204,6 +204,49 @@ function parseSort(value: string): SortValue {
   return value as SortValue;
 }
 
+/** Matches standalone boolean OR operator (word boundary, not inside a qualifier value). */
+const BOOLEAN_OR_RE = /\bOR\b/;
+/** Matches standalone boolean AND operator. */
+const BOOLEAN_AND_RE = /\bAND\b/;
+
+/**
+ * Sanitize `--query` before sending to the Sentry API.
+ *
+ * - **AND**: Sentry search implicitly ANDs space-separated terms, so explicit
+ *   `AND` has identical semantics. Strip it and warn — the user's intent is
+ *   fulfilled without error.
+ * - **OR**: Genuinely different semantics (union vs intersection). The API
+ *   rejects it with 400. Throw a helpful ValidationError since we cannot
+ *   silently approximate the intent.
+ *
+ * @returns The sanitized query string (AND stripped, OR rejected)
+ */
+function sanitizeQuery(
+  query: string,
+  log: { warn: (msg: string) => void }
+): string {
+  if (BOOLEAN_OR_RE.test(query)) {
+    throw new ValidationError(
+      "Sentry search does not support the OR operator.\n\n" +
+        "Alternatives:\n" +
+        '  - Use space-separated terms (implicit AND): --query "error timeout"\n' +
+        "  - Run separate queries for each term\n" +
+        '  - Use wildcards for partial matching: --query "*error*"\n\n' +
+        "Search syntax: https://docs.sentry.io/concepts/search/",
+      "query"
+    );
+  }
+  if (BOOLEAN_AND_RE.test(query)) {
+    const sanitized = query.replace(/\s*\bAND\b\s*/g, " ").trim();
+    log.warn(
+      "Sentry search implicitly ANDs terms — removed explicit AND operator. " +
+        `Running query: "${sanitized}"`
+    );
+    return sanitized;
+  }
+  return query;
+}
+
 /**
  * Format the issue list header with column titles.
  *
@@ -1450,6 +1493,7 @@ export const __testing = {
   getComparator,
   compareDates,
   parseSort,
+  sanitizeQuery,
   CURSOR_SEP,
   MAX_LIMIT: LIST_MAX_LIMIT,
   VALID_SORT_VALUES,
@@ -1599,6 +1643,7 @@ export const listCommand = buildListCommand("issue", {
   },
   async *func(this: SentryContext, flags: ListFlags, target?: string) {
     const { cwd } = this;
+    const log = logger.withTag("issue.list");
 
     const parsed = parseOrgProjectArg(target);
 
@@ -1616,20 +1661,25 @@ export const listCommand = buildListCommand("issue", {
       );
     }
 
-    const timeRange = parsePeriod(flags.period ?? DEFAULT_PERIOD);
+    // Sanitize --query: auto-correct AND (same semantics), reject OR (different semantics).
+    const effectiveFlags: ListFlags = flags.query
+      ? { ...flags, query: sanitizeQuery(flags.query, log) }
+      : flags;
+
+    const timeRange = parsePeriod(effectiveFlags.period ?? DEFAULT_PERIOD);
 
     // biome-ignore lint/suspicious/noExplicitAny: shared handler accepts any mode variant
     const resolveAndHandle: ModeHandler<any> = (ctx) =>
       handleResolvedTargets({
         ...ctx,
-        flags,
+        flags: effectiveFlags,
         timeRange,
       });
 
     const result = (await dispatchOrgScopedList({
       config: issueListMeta,
       cwd,
-      flags,
+      flags: effectiveFlags,
       parsed,
       // When a bare slug matches a cached org, silently redirect to org-all
       // mode instead of erroring (CLI-MC, 17 users). The user typed an org
@@ -1645,7 +1695,7 @@ export const listCommand = buildListCommand("issue", {
         "org-all": (ctx) =>
           handleOrgAllIssues({
             org: ctx.parsed.org,
-            flags,
+            flags: effectiveFlags,
             timeRange,
           }),
       },

test/commands/issue/list.property.test.ts

@@ -494,3 +494,67 @@ describe("property: buildProjectAliasMap", () => {
     expect(Object.keys(entries).length).toBe(1);
   });
 });
+
+// ---------------------------------------------------------------------------
+// sanitizeQuery
+// ---------------------------------------------------------------------------
+
+const { sanitizeQuery } = __testing;
+
+/** Generates a non-empty string that does NOT contain standalone OR or AND. */
+const safeTermArb = constantFrom(
+  "is:unresolved",
+  "level:error",
+  "timeout",
+  "crash",
+  "http.status:500",
+  "assigned:me",
+  "sandbox",
+  "order",
+  "android"
+);
+
+// biome-ignore lint/suspicious/noEmptyBlockStatements: intentional no-op
+const noopLog = { warn: () => {} };
+
+describe("property: sanitizeQuery", () => {
+  test("query with OR always throws ValidationError", () => {
+    fcAssert(
+      property(
+        tuple(safeTermArb, safeTermArb).map(([a, b]) => `${a} OR ${b}`),
+        (query) => {
+          expect(() => sanitizeQuery(query, noopLog)).toThrow();
+        }
+      ),
+      { numRuns: DEFAULT_NUM_RUNS }
+    );
+  });
+
+  test("AND removal preserves all non-AND tokens", () => {
+    fcAssert(
+      property(
+        tuple(safeTermArb, safeTermArb).map(([a, b]) => `${a} AND ${b}`),
+        (query) => {
+          const result = sanitizeQuery(query, noopLog);
+          // Both original terms must be present in the result
+          const parts = query.split(/\s+AND\s+/);
+          for (const part of parts) {
+            expect(result).toContain(part.trim());
+          }
+          // AND must not be present
+          expect(result).not.toContain("AND");
+        }
+      ),
+      { numRuns: DEFAULT_NUM_RUNS }
+    );
+  });
+
+  test("safe queries pass through unchanged", () => {
+    fcAssert(
+      property(safeTermArb, (term) => {
+        expect(sanitizeQuery(term, noopLog)).toBe(term);
+      }),
+      { numRuns: DEFAULT_NUM_RUNS }
+    );
+  });
+});

test/commands/issue/list.test.ts

@@ -15,6 +15,7 @@ import {
   test,
 } from "bun:test";
 import {
+  __testing,
   listCommand,
   PAGINATION_KEY,
 } from "../../../src/commands/issue/list.js";
@@ -29,7 +30,11 @@ import {
 // biome-ignore lint/performance/noNamespaceImport: needed for spyOn mocking
 import * as paginationDb from "../../../src/lib/db/pagination.js";
 import { setOrgRegion } from "../../../src/lib/db/regions.js";
-import { ApiError, ResolutionError } from "../../../src/lib/errors.js";
+import {
+  ApiError,
+  ResolutionError,
+  ValidationError,
+} from "../../../src/lib/errors.js";
 import { mockFetch, useTestConfigDir } from "../../helpers.js";
 
 type ListFlags = {
@@ -1122,3 +1127,81 @@ describe("issue list: collapse parameter optimization", () => {
     expect(options?.groupStatsPeriod).toBeUndefined();
   });
 });
+
+// ---------------------------------------------------------------------------
+// sanitizeQuery
+// ---------------------------------------------------------------------------
+
+const { sanitizeQuery } = __testing;
+
+/** No-op logger for tests that don't check warnings */
+// biome-ignore lint/suspicious/noEmptyBlockStatements: intentional no-op
+const noopLog = { warn: () => {} };
+
+describe("sanitizeQuery", () => {
+  test("passes through a simple query unchanged", () => {
+    expect(sanitizeQuery("is:unresolved level:error", noopLog)).toBe(
+      "is:unresolved level:error"
+    );
+  });
+
+  test("passes through a plain text query unchanged", () => {
+    expect(sanitizeQuery("timeout crash", noopLog)).toBe("timeout crash");
+  });
+
+  test("throws ValidationError for OR operator", () => {
+    expect(() => sanitizeQuery("error OR timeout", noopLog)).toThrow(
+      ValidationError
+    );
+  });
+
+  test("ValidationError for OR includes field and suggestions", () => {
+    try {
+      sanitizeQuery("login OR auth OR token", noopLog);
+      expect.unreachable("Should have thrown");
+    } catch (error) {
+      expect(error).toBeInstanceOf(ValidationError);
+      const ve = error as ValidationError;
+      expect(ve.field).toBe("query");
+      expect(ve.message).toContain("OR");
+      expect(ve.message).toContain("docs.sentry.io");
+    }
+  });
+
+  test("strips AND and returns cleaned query", () => {
+    expect(sanitizeQuery("error AND timeout", noopLog)).toBe("error timeout");
+  });
+
+  test("strips multiple AND operators", () => {
+    expect(sanitizeQuery("error AND timeout AND crash", noopLog)).toBe(
+      "error timeout crash"
+    );
+  });
+
+  test("AND removal emits a warning", () => {
+    const warnings: string[] = [];
+    const log = { warn: (msg: string) => warnings.push(msg) };
+    sanitizeQuery("error AND timeout", log);
+    expect(warnings).toHaveLength(1);
+    expect(warnings[0]).toContain("AND");
+    expect(warnings[0]).toContain("error timeout");
+  });
+
+  test("does not match lowercase 'and' or 'or'", () => {
+    // Sentry search operators are case-sensitive uppercase
+    expect(sanitizeQuery("sandbox handler", noopLog)).toBe("sandbox handler");
+    expect(sanitizeQuery("order error", noopLog)).toBe("order error");
+  });
+
+  test("rejects OR even with qualifiers mixed in", () => {
+    expect(() =>
+      sanitizeQuery("is:unresolved error OR timeout", noopLog)
+    ).toThrow(ValidationError);
+  });
+
+  test("strips AND with qualifiers", () => {
+    expect(sanitizeQuery("is:unresolved AND level:error", noopLog)).toBe(
+      "is:unresolved level:error"
+    );
+  });
+});