refactor: simplify GitHub authentication and token handling

Author: ericc-ch

src/lib/initialization.ts

@@ -1,41 +1,41 @@
 import consola from "consola"
-import { FetchError } from "ofetch"
 
 import { ensurePaths } from "~/lib/paths"
-import { tokenService } from "~/lib/token"
+import { readGithubToken, tokenService, writeGithubToken } from "~/lib/token"
+import { getDeviceCode } from "~/services/github/get-device-code"
 import { getGitHubUser } from "~/services/github/get-user/service"
+import { pollAccessToken } from "~/services/github/poll-access-token"
 
 import { getModels } from "../services/copilot/get-models/service"
-import { getGitHubToken } from "../services/github/get-token/service"
+import { state } from "./state"
 
-async function initializeGithubAuthentication(): Promise<void> {
-  const githubToken = await tokenService.getGithubToken()
+async function logUser() {
+  const user = await getGitHubUser()
+  consola.info(`Logged in as ${JSON.stringify(user.login)}\n`)
+}
 
-  try {
-    if (githubToken) {
-      // Set token in the service so github fetcher can use it
-      await tokenService.setGithubToken(githubToken)
-      await logUser()
-    } else {
-      throw new Error("No GitHub token available")
-    }
-  } catch (error) {
-    if (error instanceof FetchError && error.statusCode !== 401) {
-      consola.error("Authentication error:", {
-        error,
-        request: error.request,
-        options: error.options,
-        response: error.response,
-        data: error.response?._data as Record<string, unknown>,
-      })
-      throw error
-    }
+async function setupGitHubToken(): Promise<void> {
+  const githubToken = await readGithubToken()
 
-    consola.info("Not logged in, getting new access token")
-    const newToken = await initializeGithubToken()
-    await tokenService.setGithubToken(newToken)
+  if (githubToken) {
+    state.githubToken = githubToken
     await logUser()
+
+    return
   }
+
+  consola.info("Not logged in, getting new access token")
+  const response = await getDeviceCode()
+
+  consola.info(
+    `Please enter the code "${response.user_code}" in ${response.verification_uri}`,
+  )
+
+  const token = await pollAccessToken(response)
+  await writeGithubToken(token)
+  state.githubToken = token
+
+  await logUser()
 }
 
 async function initializeCopilotToken(): Promise<void> {
@@ -49,19 +49,9 @@ async function logModelInformation(): Promise<void> {
   )
 }
 
-async function initializeGithubToken() {
-  consola.start("Getting GitHub device code")
-  return await getGitHubToken()
-}
-
-async function logUser() {
-  const user = await getGitHubUser()
-  consola.info(`Logged in as ${JSON.stringify(user.login)}\n`)
-}
-
 export async function initializeApp() {
   await ensurePaths()
-  await initializeGithubAuthentication()
+  await setupGitHubToken()
   await initializeCopilotToken()
   await logModelInformation()
 }

src/lib/token.ts

@@ -4,6 +4,32 @@ import fs from "node:fs/promises"
 import { PATHS } from "~/lib/paths"
 import { getCopilotToken } from "~/services/copilot/get-token/copilot-token"
 
+import { state } from "./state"
+
+export const readGithubToken = () =>
+  fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8")
+
+export const writeGithubToken = (token: string) =>
+  fs.writeFile(PATHS.GITHUB_TOKEN_PATH, token)
+
+export const setupCopilotTokenRefresh = async () => {
+  const { token, refresh_in } = await getCopilotToken()
+  state.copilotToken = token
+
+  const refreshInterval = (refresh_in - 60) * 1000
+
+  setInterval(async () => {
+    consola.start("Refreshing Copilot token")
+    try {
+      const { token } = await getCopilotToken()
+      state.copilotToken = token
+    } catch (error) {
+      consola.error("Failed to refresh Copilot token:", error)
+      throw error
+    }
+  }, refreshInterval)
+}
+
 // Simple token manager with basic encapsulation
 export const tokenService = {
   // Private token storage
@@ -12,25 +38,6 @@ export const tokenService = {
     copilot: undefined as string | undefined,
   },
 
-  // Get GitHub token
-  async getGithubToken(): Promise<string | undefined> {
-    if (!this._tokens.github) {
-      try {
-        this._tokens.github = await fs.readFile(PATHS.GITHUB_TOKEN_PATH, "utf8")
-      } catch (error) {
-        consola.warn("Failed to load GitHub token", error)
-      }
-    }
-
-    return this._tokens.github
-  },
-
-  // Set GitHub token
-  async setGithubToken(token: string): Promise<void> {
-    this._tokens.github = token
-    await fs.writeFile(PATHS.GITHUB_TOKEN_PATH, token)
-  },
-
   // Get Copilot token
   getCopilotToken(): string | undefined {
     return this._tokens.copilot