refactor: clean up enterprise URL handling and simplify code patterns

- Remove unused looksLikeHost() function and tests
- Remove unnecessary type casts in url.ts
- Centralize enterprise URL reading from state
- Replace typeof checks with consistent function calls
- Update GITHUB_BASE_URL and GITHUB_API_BASE_URL to read from state.enterpriseUrl
- Remove enterpriseUrl parameters from service functions (getDeviceCode, pollAccessToken)
- Update integration tests to set state.enterpriseUrl instead of passing parameters
- Improve code consistency and maintainability

All 64 tests passing. TypeScript compiles successfully.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

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

src/lib/api-config.ts

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto"
 
 import type { State } from "./state"
 
+import { state } from "./state"
 import { githubBaseUrl, githubApiBaseUrl } from "./url"
 
 export const standardHeaders = () => ({
@@ -22,8 +23,8 @@ export const copilotBaseUrl = (state: State) => {
   }
 
   // Otherwise use standard GitHub Copilot endpoints based on account type
-  return state.accountType === "individual"
-    ? "https://api.githubcopilot.com"
+  return state.accountType === "individual" ?
+      "https://api.githubcopilot.com"
     : `https://api.${state.accountType}.githubcopilot.com`
 }
 export const copilotHeaders = (state: State, vision: boolean = false) => {
@@ -45,8 +46,7 @@ export const copilotHeaders = (state: State, vision: boolean = false) => {
   return headers
 }
 
-export const GITHUB_API_BASE_URL = (enterprise?: string) =>
-  githubApiBaseUrl(enterprise)
+export const GITHUB_API_BASE_URL = () => githubApiBaseUrl(state.enterpriseUrl)
 export const githubHeaders = (state: State) => ({
   ...standardHeaders(),
   authorization: `token ${state.githubToken}`,
@@ -57,7 +57,6 @@ export const githubHeaders = (state: State) => ({
   "x-vscode-user-agent-library-version": "electron-fetch",
 })
 
-export const GITHUB_BASE_URL = (enterprise?: string) =>
-  githubBaseUrl(enterprise)
+export const GITHUB_BASE_URL = () => githubBaseUrl(state.enterpriseUrl)
 export const GITHUB_CLIENT_ID = "Iv1.b507a08c87ecfe98"
 export const GITHUB_APP_SCOPES = ["read:user"].join(" ")

src/lib/token.ts

@@ -84,14 +84,14 @@ export async function setupGitHubToken(
     const enterpriseFromOptions = options?.enterpriseUrl
     if (enterpriseFromOptions) state.enterpriseUrl = enterpriseFromOptions
 
-    const response = await getDeviceCode(state.enterpriseUrl)
+    const response = await getDeviceCode()
     consola.debug("Device code response:", response)
 
     consola.info(
       `Please enter the code "${response.user_code}" in ${response.verification_uri}`,
     )
 
-    const token = await pollAccessToken(response, state.enterpriseUrl)
+    const token = await pollAccessToken(response)
     await writeGithubToken(token)
     // persist enterprise url if set
     await writeEnterpriseUrl(state.enterpriseUrl)

src/lib/url.ts

@@ -5,18 +5,12 @@ export function normalizeDomain(url: string | undefined): string | undefined {
 
 export function githubBaseUrl(enterprise?: string): string {
   if (!enterprise) return "https://github.com"
-  return `https://${normalizeDomain(enterprise)}`
+  const domain = normalizeDomain(enterprise)
+  return `https://${domain}`
 }
 
 export function githubApiBaseUrl(enterprise?: string): string {
   if (!enterprise) return "https://api.github.com"
-  const domain = normalizeDomain(enterprise) as string
+  const domain = normalizeDomain(enterprise)
   return `https://api.${domain}`
 }
-
-// small helper to validate a normalized host (basic check)
-export function looksLikeHost(s: string | undefined): boolean {
-  if (!s) return false
-  // allow example.com or sub.example.com and digits/hyphen
-  return /^[a-z0-9.-]+$/i.test(s)
-}

src/services/github/get-copilot-token.ts

@@ -3,14 +3,12 @@ import { HTTPError } from "~/lib/error"
 import { state } from "~/lib/state"
 
 export const getCopilotToken = async () => {
-  // default path for GitHub.com
-  const base =
-    typeof GITHUB_API_BASE_URL === "function" ?
-      GITHUB_API_BASE_URL(state.enterpriseUrl)
-    : GITHUB_API_BASE_URL
-  const response = await fetch(`${base}/copilot_internal/v2/token`, {
-    headers: githubHeaders(state),
-  })
+  const response = await fetch(
+    `${GITHUB_API_BASE_URL()}/copilot_internal/v2/token`,
+    {
+      headers: githubHeaders(state),
+    },
+  )
 
   if (!response.ok) throw new HTTPError("Failed to get Copilot token", response)
 

src/services/github/get-copilot-usage.ts

@@ -3,13 +3,12 @@ import { HTTPError } from "~/lib/error"
 import { state } from "~/lib/state"
 
 export const getCopilotUsage = async (): Promise<CopilotUsageResponse> => {
-  const base =
-    typeof GITHUB_API_BASE_URL === "function" ?
-      GITHUB_API_BASE_URL(state.enterpriseUrl)
-    : GITHUB_API_BASE_URL
-  const response = await fetch(`${base}/copilot_internal/user`, {
-    headers: githubHeaders(state),
-  })
+  const response = await fetch(
+    `${GITHUB_API_BASE_URL()}/copilot_internal/user`,
+    {
+      headers: githubHeaders(state),
+    },
+  )
 
   if (!response.ok) {
     throw new HTTPError("Failed to get Copilot usage", response)

src/services/github/get-device-code.ts

@@ -6,14 +6,8 @@ import {
 } from "~/lib/api-config"
 import { HTTPError } from "~/lib/error"
 
-export async function getDeviceCode(
-  enterpriseUrl?: string,
-): Promise<DeviceCodeResponse> {
-  const base =
-    typeof GITHUB_BASE_URL === "function" ?
-      GITHUB_BASE_URL(enterpriseUrl)
-    : GITHUB_BASE_URL
-  const response = await fetch(`${base}/login/device/code`, {
+export async function getDeviceCode(): Promise<DeviceCodeResponse> {
+  const response = await fetch(`${GITHUB_BASE_URL()}/login/device/code`, {
     method: "POST",
     headers: standardHeaders(),
     body: JSON.stringify({

src/services/github/get-user.ts

@@ -3,11 +3,7 @@ import { HTTPError } from "~/lib/error"
 import { state } from "~/lib/state"
 
 export async function getGitHubUser() {
-  const base =
-    typeof GITHUB_API_BASE_URL === "function" ?
-      GITHUB_API_BASE_URL(state.enterpriseUrl)
-    : GITHUB_API_BASE_URL
-  const response = await fetch(`${base}/user`, {
+  const response = await fetch(`${GITHUB_API_BASE_URL()}/user`, {
     headers: {
       authorization: `token ${state.githubToken}`,
       ...standardHeaders(),

src/services/github/poll-access-token.ts

@@ -11,27 +11,25 @@ import type { DeviceCodeResponse } from "./get-device-code"
 
 export async function pollAccessToken(
   deviceCode: DeviceCodeResponse,
-  enterpriseUrl?: string,
 ): Promise<string> {
   // Interval is in seconds, we need to multiply by 1000 to get milliseconds
   // I'm also adding another second, just to be safe
   const sleepDuration = (deviceCode.interval + 1) * 1000
   consola.debug(`Polling access token with interval of ${sleepDuration}ms`)
 
   while (true) {
-    const base =
-      typeof GITHUB_BASE_URL === "function" ?
-        GITHUB_BASE_URL(enterpriseUrl)
-      : GITHUB_BASE_URL
-    const response = await fetch(`${base}/login/oauth/access_token`, {
-      method: "POST",
-      headers: standardHeaders(),
-      body: JSON.stringify({
-        client_id: GITHUB_CLIENT_ID,
-        device_code: deviceCode.device_code,
-        grant_type: "urn:ietf:params:oauth:grant-type:device_code",
-      }),
-    })
+    const response = await fetch(
+      `${GITHUB_BASE_URL()}/login/oauth/access_token`,
+      {
+        method: "POST",
+        headers: standardHeaders(),
+        body: JSON.stringify({
+          client_id: GITHUB_CLIENT_ID,
+          device_code: deviceCode.device_code,
+          grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+        }),
+      },
+    )
 
     if (!response.ok) {
       await sleep(sleepDuration)

tests/copilot-base-url.test.ts

@@ -1,7 +1,9 @@
 import { describe, it, expect } from "bun:test"
-import { copilotBaseUrl } from "../src/lib/api-config"
+
 import type { State } from "../src/lib/state"
 
+import { copilotBaseUrl } from "../src/lib/api-config"
+
 describe("copilotBaseUrl", () => {
   it("should return api.githubcopilot.com for individual account without enterprise", () => {
     const state: State = {

tests/enterprise-integration.test.ts

@@ -1,13 +1,14 @@
 import { describe, it, expect, beforeEach, afterEach, mock } from "bun:test"
-import { getDeviceCode } from "../src/services/github/get-device-code"
-import { pollAccessToken } from "../src/services/github/poll-access-token"
+
+import { state } from "../src/lib/state"
 import { getCopilotToken } from "../src/services/github/get-copilot-token"
 import { getCopilotUsage } from "../src/services/github/get-copilot-usage"
+import { getDeviceCode } from "../src/services/github/get-device-code"
 import { getGitHubUser } from "../src/services/github/get-user"
-import { state } from "../src/lib/state"
+import { pollAccessToken } from "../src/services/github/poll-access-token"
 
 describe("Enterprise OAuth Integration", () => {
-  const originalFetch = global.fetch
+  const originalFetch = globalThis.fetch
   let fetchCalls: Array<{ url: string; options?: any }> = []
 
   beforeEach(() => {
@@ -18,12 +19,12 @@ describe("Enterprise OAuth Integration", () => {
   })
 
   afterEach(() => {
-    global.fetch = originalFetch
+    globalThis.fetch = originalFetch
   })
 
   describe("getDeviceCode", () => {
     it("should use github.com when no enterprise URL", async () => {
-      global.fetch = mock((url: string, options?: any) => {
+      globalThis.fetch = mock((url: string, options?: any) => {
         fetchCalls.push({ url, options })
         return Promise.resolve({
           ok: true,
@@ -45,7 +46,9 @@ describe("Enterprise OAuth Integration", () => {
     })
 
     it("should use enterprise URL when provided", async () => {
-      global.fetch = mock((url: string, options?: any) => {
+      state.enterpriseUrl = "ghe.example.com"
+
+      globalThis.fetch = mock((url: string, options?: any) => {
         fetchCalls.push({ url, options })
         return Promise.resolve({
           ok: true,
@@ -60,7 +63,7 @@ describe("Enterprise OAuth Integration", () => {
         })
       }) as any
 
-      await getDeviceCode("ghe.example.com")
+      await getDeviceCode()
 
       expect(fetchCalls.length).toBe(1)
       expect(fetchCalls[0].url).toBe(
@@ -69,7 +72,9 @@ describe("Enterprise OAuth Integration", () => {
     })
 
     it("should normalize enterprise URL with https prefix", async () => {
-      global.fetch = mock((url: string, options?: any) => {
+      state.enterpriseUrl = "https://ghe.example.com/"
+
+      globalThis.fetch = mock((url: string, options?: any) => {
         fetchCalls.push({ url, options })
         return Promise.resolve({
           ok: true,
@@ -84,7 +89,7 @@ describe("Enterprise OAuth Integration", () => {
         })
       }) as any
 
-      await getDeviceCode("https://ghe.example.com/")
+      await getDeviceCode()
 
       expect(fetchCalls.length).toBe(1)
       expect(fetchCalls[0].url).toBe(
@@ -103,7 +108,7 @@ describe("Enterprise OAuth Integration", () => {
     }
 
     it("should use github.com when no enterprise URL", async () => {
-      global.fetch = mock((url: string, options?: any) => {
+      globalThis.fetch = mock((url: string, options?: any) => {
         fetchCalls.push({ url, options })
         return Promise.resolve({
           ok: true,
@@ -125,7 +130,9 @@ describe("Enterprise OAuth Integration", () => {
     })
 
     it("should use enterprise URL when provided", async () => {
-      global.fetch = mock((url: string, options?: any) => {
+      state.enterpriseUrl = "ghe.example.com"
+
+      globalThis.fetch = mock((url: string, options?: any) => {
         fetchCalls.push({ url, options })
         return Promise.resolve({
           ok: true,
@@ -138,7 +145,7 @@ describe("Enterprise OAuth Integration", () => {
         })
       }) as any
 
-      await pollAccessToken(deviceCodeResponse, "ghe.example.com")
+      await pollAccessToken(deviceCodeResponse)
 
       expect(fetchCalls.length).toBe(1)
       expect(fetchCalls[0].url).toBe(
@@ -151,7 +158,7 @@ describe("Enterprise OAuth Integration", () => {
     it("should use api.github.com when no enterprise URL", async () => {
       state.enterpriseUrl = undefined
 
-      global.fetch = mock((url: string, options?: any) => {
+      globalThis.fetch = mock((url: string, options?: any) => {
         fetchCalls.push({ url, options })
         return Promise.resolve({
           ok: true,
@@ -175,7 +182,7 @@ describe("Enterprise OAuth Integration", () => {
     it("should use enterprise API URL when configured", async () => {
       state.enterpriseUrl = "ghe.example.com"
 
-      global.fetch = mock((url: string, options?: any) => {
+      globalThis.fetch = mock((url: string, options?: any) => {
         fetchCalls.push({ url, options })
         return Promise.resolve({
           ok: true,
@@ -201,7 +208,7 @@ describe("Enterprise OAuth Integration", () => {
     it("should use api.github.com when no enterprise URL", async () => {
       state.enterpriseUrl = undefined
 
-      global.fetch = mock((url: string, options?: any) => {
+      globalThis.fetch = mock((url: string, options?: any) => {
         fetchCalls.push({ url, options })
         return Promise.resolve({
           ok: true,
@@ -227,7 +234,7 @@ describe("Enterprise OAuth Integration", () => {
     it("should use enterprise API URL when configured", async () => {
       state.enterpriseUrl = "ghe.example.com"
 
-      global.fetch = mock((url: string, options?: any) => {
+      globalThis.fetch = mock((url: string, options?: any) => {
         fetchCalls.push({ url, options })
         return Promise.resolve({
           ok: true,
@@ -255,7 +262,7 @@ describe("Enterprise OAuth Integration", () => {
     it("should use api.github.com when no enterprise URL", async () => {
       state.enterpriseUrl = undefined
 
-      global.fetch = mock((url: string, options?: any) => {
+      globalThis.fetch = mock((url: string, options?: any) => {
         fetchCalls.push({ url, options })
         return Promise.resolve({
           ok: true,
@@ -275,7 +282,7 @@ describe("Enterprise OAuth Integration", () => {
     it("should use enterprise API URL when configured", async () => {
       state.enterpriseUrl = "ghe.example.com"
 
-      global.fetch = mock((url: string, options?: any) => {
+      globalThis.fetch = mock((url: string, options?: any) => {
         fetchCalls.push({ url, options })
         return Promise.resolve({
           ok: true,

tests/enterprise-persistence.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeEach, afterEach } from "bun:test"
 import fs from "node:fs/promises"
-import path from "node:path"
 import os from "node:os"
+import path from "node:path"
 
 describe("Enterprise URL Persistence", () => {
   const TEST_APP_DIR = path.join(os.tmpdir(), "copilot-api-test")

tests/url.test.ts

@@ -4,7 +4,6 @@ import {
   normalizeDomain,
   githubBaseUrl,
   githubApiBaseUrl,
-  looksLikeHost,
 } from "../src/lib/url"
 
 describe("URL helpers", () => {
@@ -64,24 +63,4 @@ describe("URL helpers", () => {
       )
     })
   })
-
-  describe("looksLikeHost", () => {
-    it("returns false for empty/undefined input", () => {
-      expect(looksLikeHost(undefined)).toBe(false)
-      expect(looksLikeHost("")).toBe(false)
-    })
-
-    it("returns true for valid hostnames", () => {
-      expect(looksLikeHost("ghe.example.com")).toBe(true)
-      expect(looksLikeHost("sub.ghe.example.com")).toBe(true)
-      expect(looksLikeHost("localhost")).toBe(true)
-      expect(looksLikeHost("github-enterprise.company.com")).toBe(true)
-    })
-
-    it("returns false for invalid hostnames", () => {
-      expect(looksLikeHost("invalid host with spaces")).toBe(false)
-      expect(looksLikeHost("http://ghe.example.com")).toBe(false)
-      expect(looksLikeHost("ghe.example.com/path")).toBe(false)
-    })
-  })
 })