fix(arg-parsing): strip DSN 'o' prefix from org identifiers (#CLI-AA)

When users or AI agents extract org identifiers from Sentry DSN hosts
(e.g., o1081365 from o1081365.ingest.us.sentry.io) and pass them as CLI
arguments, the 'o' prefix causes API failures since the Sentry API
accepts numeric org IDs but not the o-prefixed DSN form.

Add stripDsnOrgPrefix() that normalizes oNNNNN → NNNNN in:
- parseOrgProjectArg() for org-all and explicit modes
- parseWithSlash() for issue arg parsing

The pattern /^o(\d+)$/ only matches 'o' followed by pure digits,
so normal slugs like 'organic' or 'o1abc' are unaffected.

Fixes CLI-AA

Author: BYK

src/lib/arg-parsing.ts

@@ -11,6 +11,41 @@ import type { ParsedSentryUrl } from "./sentry-url-parser.js";
 import { applySentryUrlContext, parseSentryUrl } from "./sentry-url-parser.js";
 import { isAllDigits } from "./utils.js";
 
+/**
+ * Pattern matching DSN-style org identifiers: "o" followed by only digits.
+ *
+ * Sentry DSN hosts encode org IDs as `oNNNNN.ingest[.region].sentry.io`
+ * (e.g., `o1081365.ingest.us.sentry.io`). When users or AI agents extract
+ * the org portion from a DSN and pass it as a CLI argument (e.g.,
+ * `sentry event view o1081365/ <event-id>`), the `o` prefix must be
+ * stripped because the Sentry API accepts numeric org IDs but not the
+ * `o`-prefixed DSN form.
+ */
+const DSN_ORG_PREFIX_PATTERN = /^o(\d+)$/;
+
+/**
+ * Normalize a DSN-style org identifier to a numeric org ID.
+ *
+ * DSN hosts encode org IDs as `oNNNNN` (e.g., `o1081365` from
+ * `o1081365.ingest.us.sentry.io`). The Sentry API accepts numeric IDs
+ * via `organization_id_or_slug` path parameters, but not the `o`-prefixed
+ * DSN form.
+ *
+ * @param org - Raw org identifier from CLI input
+ * @returns The numeric org ID if input matches `oNNNNN`, otherwise unchanged
+ *
+ * @example
+ * stripDsnOrgPrefix("o1081365")  // "1081365"
+ * stripDsnOrgPrefix("o123")      // "123"
+ * stripDsnOrgPrefix("sentry")    // "sentry"  (no change)
+ * stripDsnOrgPrefix("organic")   // "organic" (no change — not all digits after 'o')
+ *
+ * @internal Exported for testing
+ */
+export function stripDsnOrgPrefix(org: string): string {
+  return org.replace(DSN_ORG_PREFIX_PATTERN, "$1");
+}
+
 /**
  * Validate that a CLI --limit flag value is within an allowed range.
  *
@@ -224,11 +259,11 @@ export function parseOrgProjectArg(arg: string | undefined): ParsedOrgProject {
 
     if (!project) {
       // "sentry/" → list all projects in org
-      return { type: "org-all", org };
+      return { type: "org-all", org: stripDsnOrgPrefix(org) };
     }
 
     // "sentry/cli" → explicit org and project
-    return { type: "explicit", org, project };
+    return { type: "explicit", org: stripDsnOrgPrefix(org), project };
   }
 
   // No slash → search for project across all orgs
@@ -325,7 +360,7 @@ function parseAfterSlash(
  */
 function parseWithSlash(arg: string): ParsedIssueArg {
   const slashIdx = arg.indexOf("/");
-  const org = arg.slice(0, slashIdx);
+  const rawOrg = arg.slice(0, slashIdx);
   const rest = arg.slice(slashIdx + 1);
 
   if (!rest) {
@@ -334,7 +369,7 @@ function parseWithSlash(arg: string): ParsedIssueArg {
     );
   }
 
-  if (!org) {
+  if (!rawOrg) {
     // Leading slash with dash → project-search (e.g., "/cli-G")
     if (rest.includes("-")) {
       return parseWithDash(rest);
@@ -343,6 +378,7 @@ function parseWithSlash(arg: string): ParsedIssueArg {
     return { type: "suffix-only", suffix: rest.toUpperCase() };
   }
 
+  const org = stripDsnOrgPrefix(rawOrg);
   return parseAfterSlash(arg, org, rest);
 }
 

test/lib/arg-parsing.test.ts

@@ -10,9 +10,42 @@ import { afterEach, beforeEach, describe, expect, test } from "bun:test";
 import {
   parseIssueArg,
   parseOrgProjectArg,
+  stripDsnOrgPrefix,
 } from "../../src/lib/arg-parsing.js";
 import { ValidationError } from "../../src/lib/errors.js";
 
+describe("stripDsnOrgPrefix", () => {
+  test("strips 'o' prefix from DSN-style org IDs", () => {
+    expect(stripDsnOrgPrefix("o1081365")).toBe("1081365");
+    expect(stripDsnOrgPrefix("o123")).toBe("123");
+    expect(stripDsnOrgPrefix("o0")).toBe("0");
+    expect(stripDsnOrgPrefix("o9999999999")).toBe("9999999999");
+  });
+
+  test("preserves normal org slugs", () => {
+    expect(stripDsnOrgPrefix("sentry")).toBe("sentry");
+    expect(stripDsnOrgPrefix("my-org")).toBe("my-org");
+    expect(stripDsnOrgPrefix("acme-corp")).toBe("acme-corp");
+  });
+
+  test("preserves slugs starting with 'o' that have non-digit chars", () => {
+    expect(stripDsnOrgPrefix("organic")).toBe("organic");
+    expect(stripDsnOrgPrefix("org-name")).toBe("org-name");
+    expect(stripDsnOrgPrefix("o1abc")).toBe("o1abc");
+    expect(stripDsnOrgPrefix("open123")).toBe("open123");
+  });
+
+  test("preserves pure numeric strings (no 'o' prefix)", () => {
+    expect(stripDsnOrgPrefix("1081365")).toBe("1081365");
+    expect(stripDsnOrgPrefix("123")).toBe("123");
+  });
+
+  test("preserves empty string and 'o' alone", () => {
+    expect(stripDsnOrgPrefix("")).toBe("");
+    expect(stripDsnOrgPrefix("o")).toBe("o");
+  });
+});
+
 describe("parseOrgProjectArg", () => {
   // Representative examples for documentation (invariants covered by property tests)
   test("org/project returns explicit", () => {
@@ -38,6 +71,40 @@ describe("parseOrgProjectArg", () => {
     );
   });
 
+  // DSN org prefix normalization (Fixes CLI-AA)
+  describe("DSN org prefix normalization", () => {
+    test("strips 'o' prefix in org-all mode", () => {
+      expect(parseOrgProjectArg("o1081365/")).toEqual({
+        type: "org-all",
+        org: "1081365",
+      });
+    });
+
+    test("strips 'o' prefix in explicit mode", () => {
+      expect(parseOrgProjectArg("o1081365/myproject")).toEqual({
+        type: "explicit",
+        org: "1081365",
+        project: "myproject",
+      });
+    });
+
+    test("does not strip from normal org slugs", () => {
+      expect(parseOrgProjectArg("organic/cli")).toEqual({
+        type: "explicit",
+        org: "organic",
+        project: "cli",
+      });
+    });
+
+    test("does not strip from slugs with mixed chars after 'o'", () => {
+      expect(parseOrgProjectArg("o1abc/cli")).toEqual({
+        type: "explicit",
+        org: "o1abc",
+        project: "cli",
+      });
+    });
+  });
+
   // URL integration tests — applySentryUrlContext may set SENTRY_URL as a side effect
   describe("Sentry URL inputs", () => {
     let savedSentryUrl: string | undefined;
@@ -264,6 +331,43 @@ describe("parseIssueArg", () => {
     });
   });
 
+  // DSN org prefix normalization (Fixes CLI-AA)
+  describe("DSN org prefix normalization", () => {
+    test("strips 'o' prefix from DSN-style org in explicit", () => {
+      expect(parseIssueArg("o1081365/CLI-G")).toEqual({
+        type: "explicit",
+        org: "1081365",
+        project: "CLI",
+        suffix: "G",
+      });
+    });
+
+    test("strips 'o' prefix from DSN-style org in explicit-org-numeric", () => {
+      expect(parseIssueArg("o999/123456789")).toEqual({
+        type: "explicit-org-numeric",
+        org: "999",
+        numericId: "123456789",
+      });
+    });
+
+    test("strips 'o' prefix from DSN-style org in explicit-org-suffix", () => {
+      expect(parseIssueArg("o1081365/G")).toEqual({
+        type: "explicit-org-suffix",
+        org: "1081365",
+        suffix: "G",
+      });
+    });
+
+    test("does not strip from normal org slugs in issue args", () => {
+      expect(parseIssueArg("organic/cli-G")).toEqual({
+        type: "explicit",
+        org: "organic",
+        project: "cli",
+        suffix: "G",
+      });
+    });
+  });
+
   // Edge cases - document tricky behaviors
   describe("edge cases", () => {
     test("/suffix returns suffix-only", () => {