fix(init): resolve numeric org ID from DSN and prompt when Sentry already configured

When `sentry init .` is run in a project with an existing Sentry DSN, the CLI
was extracting the numeric org ID (e.g. `4507492088676352`) from the DSN and
passing it directly to the API as an org slug. If the org belonged to a
different Sentry account (or the org regions cache was empty after a fresh
install), this caused a confusing 404 error: "Organization '4507492088676352'
not found."

Fix the numeric ID fallback in `resolveOrgFromDsn`: instead of returning the
raw numeric ID, look it up in the org regions cache via `getOrgByNumericId`.
If found, use the real slug. If not (empty cache or inaccessible org), return
null so the caller falls through to `listOrganizations()` for proper
interactive org selection.

Also add a UX improvement: before creating a new Sentry project, detect
whether the codebase already has a Sentry DSN that resolves to an accessible
project. If so, prompt the user: "Found an existing Sentry project. Use it
or create a new one?" This avoids silently creating a duplicate project when
Sentry is already configured.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: betegon

src/lib/init/local-ops.ts

@@ -744,6 +744,54 @@ async function tryGetExistingProject(
   }
 }
 
+/**
+ * Detect an existing Sentry project by looking for a DSN in the project.
+ *
+ * Returns org and project slugs when the DSN's project can be resolved —
+ * either from the local cache or via API (when the org is accessible).
+ * Returns null when no DSN is found or the org belongs to a different account.
+ */
+async function detectExistingProject(cwd: string): Promise<{
+  orgSlug: string;
+  projectSlug: string;
+} | null> {
+  const { detectDsn } = await import("../dsn/index.js");
+  const dsn = await detectDsn(cwd);
+  if (!dsn?.publicKey) return null;
+
+  // Check public-key cache first (no API call if previously resolved)
+  const { getCachedProjectByDsnKey } = await import("../db/project-cache.js");
+  const cached = await getCachedProjectByDsnKey(dsn.publicKey);
+  if (cached) {
+    return { orgSlug: cached.orgSlug, projectSlug: cached.projectSlug };
+  }
+
+  // Cache miss — try API (only succeeds if user has access to the org)
+  try {
+    const { findProjectByDsnKey } = await import("../api-client.js");
+    const project = await findProjectByDsnKey(dsn.publicKey);
+    if (project?.organization?.slug && project.slug) {
+      const { setCachedProjectByDsnKey } = await import(
+        "../db/project-cache.js"
+      );
+      await setCachedProjectByDsnKey(dsn.publicKey, {
+        orgSlug: project.organization.slug,
+        orgName: project.organization.name ?? project.organization.slug,
+        projectSlug: project.slug,
+        projectName: project.name,
+        projectId: project.id,
+      });
+      return {
+        orgSlug: project.organization.slug,
+        projectSlug: project.slug,
+      };
+    }
+  } catch {
+    // Org inaccessible (different account) or network error — fall through
+  }
+  return null;
+}
+
 async function createSentryProject(
   payload: CreateSentryProjectPayload,
   options: WizardOptions
@@ -773,6 +821,48 @@ async function createSentryProject(
     };
   }
 
+  // When no explicit org/project provided, check if Sentry is already set up
+  if (!options.org && !options.project) {
+    const existing = await detectExistingProject(payload.cwd);
+    if (existing) {
+      if (options.yes) {
+        // Non-interactive: auto-use existing project
+        const result = await tryGetExistingProject(
+          existing.orgSlug,
+          existing.projectSlug
+        );
+        if (result) return result;
+      } else {
+        const choice = await select({
+          message: "Found an existing Sentry project in this codebase.",
+          options: [
+            {
+              value: "existing" as const,
+              label: `Use existing project (${existing.orgSlug}/${existing.projectSlug})`,
+              hint: "Sentry is already configured here",
+            },
+            {
+              value: "create" as const,
+              label: "Create a new Sentry project",
+            },
+          ],
+        });
+        if (isCancel(choice)) {
+          return { ok: false, error: "Cancelled." };
+        }
+        if (choice === "existing") {
+          const result = await tryGetExistingProject(
+            existing.orgSlug,
+            existing.projectSlug
+          );
+          if (result) return result;
+          // Project deleted or inaccessible — fall through to creation
+        }
+        // choice === "create": fall through to normal org resolution + creation
+      }
+    }
+  }
+
   try {
     // 1. Resolve org — skip interactive resolution if explicitly provided via CLI arg
     let orgSlug: string;

src/lib/resolve-target.ts

@@ -231,11 +231,18 @@ export async function resolveOrgFromDsn(
     }
   }
 
-  // Fall back to numeric org ID (API accepts both slug and numeric ID)
-  return {
-    org: dsn.orgId,
-    detectedFrom,
-  };
+  // Check org regions cache for a slug mapped to this numeric ID.
+  // The cache is populated by `sentry auth login` and `org list`.
+  const { getOrgByNumericId } = await import("./db/regions.js");
+  const orgMatch = await getOrgByNumericId(dsn.orgId);
+  if (orgMatch) {
+    return { org: orgMatch.slug, detectedFrom };
+  }
+
+  // Can't resolve to slug (empty cache or org belongs to a different account).
+  // Return null so the caller falls through to listOrganizations() for proper
+  // interactive org selection instead of passing a raw numeric ID to the API.
+  return null;
 }
 
 /**

test/isolated/resolve-target.test.ts

@@ -53,6 +53,7 @@ const mockGetProject = mock(() =>
 );
 const mockFindProjectByDsnKey = mock(() => Promise.resolve(null));
 const mockFindProjectsByPattern = mock(() => Promise.resolve([]));
+const mockGetOrgByNumericId = mock(() => Promise.resolve(undefined));
 
 // Mock all dependency modules
 mock.module("../../src/lib/db/defaults.js", () => ({
@@ -91,6 +92,10 @@ mock.module("../../src/lib/api-client.js", () => ({
   findProjectsByPattern: mockFindProjectsByPattern,
 }));
 
+mock.module("../../src/lib/db/regions.js", () => ({
+  getOrgByNumericId: mockGetOrgByNumericId,
+}));
+
 import { ContextError } from "../../src/lib/errors.js";
 // Now import the module under test (after mocks are set up)
 import {
@@ -118,6 +123,7 @@ function resetAllMocks() {
   mockGetProject.mockReset();
   mockFindProjectByDsnKey.mockReset();
   mockFindProjectsByPattern.mockReset();
+  mockGetOrgByNumericId.mockReset();
 
   // Set sensible defaults
   mockGetDefaultOrganization.mockResolvedValue(null);
@@ -139,6 +145,7 @@ function resetAllMocks() {
   mockGetCachedProject.mockResolvedValue(null);
   mockGetCachedProjectByDsnKey.mockResolvedValue(null);
   mockGetCachedDsn.mockResolvedValue(null);
+  mockGetOrgByNumericId.mockResolvedValue(undefined);
   mockFindProjectsByPattern.mockResolvedValue([]);
 }
 
@@ -198,7 +205,26 @@ describe("resolveOrg", () => {
     expect(mockDetectDsn).toHaveBeenCalled();
   });
 
-  test("returns numeric orgId when DSN detected but no cache", async () => {
+  test("returns null when DSN detected but no project/org cache", async () => {
+    mockGetDefaultOrganization.mockResolvedValue(null);
+    mockDetectDsn.mockResolvedValue({
+      raw: "https://abc@o123.ingest.sentry.io/456",
+      protocol: "https",
+      publicKey: "abc",
+      host: "o123.ingest.sentry.io",
+      projectId: "456",
+      orgId: "123",
+      source: "env",
+    });
+    mockGetCachedProject.mockResolvedValue(null);
+    mockGetOrgByNumericId.mockResolvedValue(undefined);
+
+    const result = await resolveOrg({ cwd: "/test" });
+
+    expect(result).toBeNull();
+  });
+
+  test("resolves org slug from regions cache when project cache misses", async () => {
     mockGetDefaultOrganization.mockResolvedValue(null);
     mockDetectDsn.mockResolvedValue({
       raw: "https://abc@o123.ingest.sentry.io/456",
@@ -210,11 +236,16 @@ describe("resolveOrg", () => {
       source: "env",
     });
     mockGetCachedProject.mockResolvedValue(null);
+    mockGetOrgByNumericId.mockResolvedValue({
+      slug: "my-org",
+      regionUrl: "https://sentry.io",
+    });
 
     const result = await resolveOrg({ cwd: "/test" });
 
     expect(result).not.toBeNull();
-    expect(result?.org).toBe("123");
+    expect(result?.org).toBe("my-org");
+    expect(mockGetOrgByNumericId).toHaveBeenCalledWith("123");
   });
 
   test("returns null when no org found from any source", async () => {