refactor(init): reuse resolveOrg for offline-first org detection (#666)

## Summary

The init wizard's `resolveOrgSlug()` was reimplementing org detection
that `resolveOrg()` in `resolve-target.ts` already handles. The shared
resolver covers CLI flags, env vars (`SENTRY_ORG`), config defaults, and
DSN auto-detection with numeric ID normalization — the init version only
did DSN scanning and missed env vars and config defaults entirely.

Now `resolveOrgSlug()` calls `resolveOrg({ cwd })` first, and only falls
through to `listOrganizations()` + interactive select when nothing is
detected offline.

## Test Plan

- [x] `bun test test/lib/init/` — 165 tests passing
- [ ] `sentry init` with `SENTRY_ORG=<slug>` set — should pick it up
without prompting
- [ ] `sentry init` without env vars — should still show org picker as
before

---------

Co-authored-by: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: betegon

src/lib/init/local-ops.ts

@@ -40,9 +40,6 @@ import type {
   WizardOptions,
 } from "./types.js";
 
-/** Matches a bare numeric org ID extracted from a DSN (e.g. "4507492088676352"). */
-const NUMERIC_ORG_ID_RE = /^\d+$/;
-
 /** Whitespace characters used for JSON indentation. */
 const Indenter = {
   SPACE: " ",
@@ -709,39 +706,38 @@ async function applyPatchset(
   return { ok: true, data: { applied } };
 }
 
+/** Matches a bare numeric org ID extracted from a DSN (e.g. "4507492088676352"). */
+const NUMERIC_ORG_ID_RE = /^\d+$/;
+
 /**
- * Resolve the org slug from local config, env vars, or by listing the user's
- * organizations from the API as a fallback.
+ * Resolve the org slug using the shared offline-first resolver, falling back
+ * to interactive selection when multiple orgs are available.
  *
- * DSN scanning uses the prefetch-aware helper from `./prefetch.ts` — if
+ * Uses the prefetch-aware helper from `./prefetch.ts` — if
  * {@link warmOrgDetection} was called earlier (by `init.ts`), the result is
  * already cached and returns near-instantly.
  *
- * `listOrganizations()` uses SQLite caching for near-instant warm lookups
- * (populated after `sentry login` or the first API call), so it does not
- * need background prefetching.
+ * Resolution priority (via `resolveOrg`):
+ * 1. CLI `--org` flag
+ * 2. `SENTRY_ORG` / `SENTRY_PROJECT` env vars
+ * 3. Config defaults (SQLite)
+ * 4. DSN auto-detection (with numeric ID normalization)
+ *
+ * If none of the above resolve, lists the user's organizations (SQLite-cached
+ * after `sentry login`) and prompts for selection.
  *
  * @returns The org slug on success, or a {@link LocalOpResult} error to return early.
  */
 export async function resolveOrgSlug(
   cwd: string,
   yes: boolean
 ): Promise<string | LocalOpResult> {
+  // normalizeNumericOrg inside resolveOrg may return a raw numeric ID when
+  // the cache is cold and the API refresh fails. Numeric IDs break write
+  // operations (project/team creation), so fall through to the org picker.
   const resolved = await resolveOrgPrefetched(cwd);
-  if (resolved) {
-    // If the detected org is a raw numeric ID (extracted from a DSN), try to
-    // resolve it to a real slug. Numeric IDs can fail for write operations like
-    // project/team creation, and may belong to a different Sentry account.
-    if (NUMERIC_ORG_ID_RE.test(resolved.org)) {
-      const { getOrgByNumericId } = await import("../db/regions.js");
-      const match = getOrgByNumericId(resolved.org);
-      if (match) {
-        return match.slug;
-      }
-      // Cache miss — fall through to listOrganizations() for proper selection
-    } else {
-      return resolved.org;
-    }
+  if (resolved && !NUMERIC_ORG_ID_RE.test(resolved.org)) {
+    return resolved.org;
   }
 
   // Fallback: list user's organizations (SQLite-cached after login/first call)

test/lib/init/local-ops.create-sentry-project.test.ts

@@ -295,23 +295,18 @@ describe("create-sentry-project", () => {
     expect(data.dsn).toBe("");
   });
 
-  describe("resolveOrgSlug — numeric org ID from DSN", () => {
-    test("numeric ID + cache hit → resolved to slug", async () => {
-      resolveOrgPrefetchedSpy.mockResolvedValue({ org: "4507492088676352" });
-      getOrgByNumericIdSpy.mockReturnValue({
-        slug: "acme-corp",
-        regionUrl: "https://us.sentry.io",
-      });
+  describe("resolveOrgSlug — resolveOrg integration", () => {
+    test("returns org slug when resolveOrg resolves", async () => {
+      resolveOrgPrefetchedSpy.mockResolvedValue({ org: "acme-corp" });
 
       const result = await resolveOrgSlug("/tmp/test", false);
 
       expect(result).toBe("acme-corp");
-      expect(getOrgByNumericIdSpy).toHaveBeenCalledWith("4507492088676352");
+      expect(listOrgsSpy).not.toHaveBeenCalled();
     });
 
-    test("numeric ID + cache miss → falls through to single org in listOrganizations", async () => {
-      resolveOrgPrefetchedSpy.mockResolvedValue({ org: "4507492088676352" });
-      getOrgByNumericIdSpy.mockReturnValue(undefined);
+    test("falls through to listOrganizations when resolveOrg returns null", async () => {
+      resolveOrgPrefetchedSpy.mockResolvedValue(null);
       listOrgsSpy.mockResolvedValue([
         { id: "1", slug: "solo-org", name: "Solo Org" },
       ]);
@@ -321,20 +316,15 @@ describe("create-sentry-project", () => {
       expect(result).toBe("solo-org");
     });
 
-    test("numeric ID + cache miss + multiple orgs + --yes → error with org list", async () => {
+    test("numeric ID from resolveOrg falls through to org picker", async () => {
       resolveOrgPrefetchedSpy.mockResolvedValue({ org: "4507492088676352" });
-      getOrgByNumericIdSpy.mockReturnValue(undefined);
       listOrgsSpy.mockResolvedValue([
-        { id: "1", slug: "org-a", name: "Org A" },
-        { id: "2", slug: "org-b", name: "Org B" },
+        { id: "1", slug: "solo-org", name: "Solo Org" },
       ]);
 
-      const result = await resolveOrgSlug("/tmp/test", true);
+      const result = await resolveOrgSlug("/tmp/test", false);
 
-      expect(typeof result).toBe("object");
-      const err = result as { ok: boolean; error: string };
-      expect(err.ok).toBe(false);
-      expect(err.error).toContain("Multiple organizations found");
+      expect(result).toBe("solo-org");
     });
   });