feat: Add show-token flag to display tokens on auth and refresh

Author: ericc-ch

eslint.config.ts

@@ -52,7 +52,6 @@
     "@types/bun": "^1.2.16",
     "bumpp": "^10.2.0",
     "eslint": "^9.29.0",
-    "jiti": "^2.4.2",
     "knip": "^5.61.2",
     "lint-staged": "^16.1.2",
     "prettier-plugin-packagejson": "^2.5.15",

package.json

@@ -4,10 +4,12 @@ import { defineCommand } from "citty"
 import consola from "consola"
 
 import { PATHS, ensurePaths } from "./lib/paths"
+import { state } from "./lib/state"
 import { setupGitHubToken } from "./lib/token"
 
 interface RunAuthOptions {
   verbose: boolean
+  showToken: boolean
 }
 
 export async function runAuth(options: RunAuthOptions): Promise<void> {
@@ -16,6 +18,8 @@ export async function runAuth(options: RunAuthOptions): Promise<void> {
     consola.info("Verbose logging enabled")
   }
 
+  state.showToken = options.showToken
+
   await ensurePaths()
   await setupGitHubToken({ force: true })
   consola.success("GitHub token written to", PATHS.GITHUB_TOKEN_PATH)
@@ -33,10 +37,16 @@ export const auth = defineCommand({
       default: false,
       description: "Enable verbose logging",
     },
+    "show-token": {
+      type: "boolean",
+      default: false,
+      description: "Show GitHub token on auth",
+    },
   },
   run({ args }) {
     return runAuth({
       verbose: args.verbose,
+      showToken: args["show-token"],
     })
   },
 })

src/auth.ts

@@ -10,6 +10,7 @@ export interface State {
 
   manualApprove: boolean
   rateLimitWait: boolean
+  showToken: boolean
 
   // Rate limiting configuration
   rateLimitSeconds?: number
@@ -20,4 +21,5 @@ export const state: State = {
   accountType: "individual",
   manualApprove: false,
   rateLimitWait: false,
+  showToken: false,
 }

src/lib/state.ts

@@ -20,18 +20,21 @@ export const setupCopilotToken = async () => {
   state.copilotToken = token
 
   // Display the Copilot token to the screen
-  consola.success("GitHub Copilot Token fetched successfully!")
-  consola.info(`Token: ${token}`)
-  consola.info(`Token validity: ${Math.floor(refresh_in / 60)} minutes`)
+  consola.debug("GitHub Copilot Token fetched successfully!")
+  if (state.showToken) {
+    consola.info("Copilot token:", token)
+  }
 
   const refreshInterval = (refresh_in - 60) * 1000
   setInterval(async () => {
-    consola.start("Refreshing Copilot token")
+    consola.debug("Refreshing Copilot token")
     try {
       const { token } = await getCopilotToken()
       state.copilotToken = token
-      consola.success("Copilot token refreshed")
-      consola.info(`New Token: ${token}`)
+      consola.debug("Copilot token refreshed")
+      if (state.showToken) {
+        consola.info("Refreshed Copilot token:", token)
+      }
     } catch (error) {
       consola.error("Failed to refresh Copilot token:", error)
       throw error
@@ -51,6 +54,9 @@ export async function setupGitHubToken(
 
     if (githubToken && !options?.force) {
       state.githubToken = githubToken
+      if (state.showToken) {
+        consola.info("GitHub token:", githubToken)
+      }
       await logUser()
 
       return
@@ -68,6 +74,9 @@ export async function setupGitHubToken(
     await writeGithubToken(token)
     state.githubToken = token
 
+    if (state.showToken) {
+      consola.info("GitHub token:", token)
+    }
     await logUser()
   } catch (error) {
     if (error instanceof HTTPError) {

src/lib/token.ts

@@ -1,180 +1,9 @@
 #!/usr/bin/env node
 
 import { defineCommand, runMain } from "citty"
-import clipboard from "clipboardy"
-import consola from "consola"
-import { serve, type ServerHandler } from "srvx"
-import invariant from "tiny-invariant"
 
 import { auth } from "./auth"
-import { ensurePaths } from "./lib/paths"
-import { generateEnvScript } from "./lib/shell"
-import { state } from "./lib/state"
-import { setupCopilotToken, setupGitHubToken } from "./lib/token"
-import { cacheModels, cacheVSCodeVersion } from "./lib/utils"
-import { server } from "./server"
-
-interface RunServerOptions {
-  port: number
-  verbose: boolean
-  accountType: string
-  manual: boolean
-  rateLimit?: number
-  rateLimitWait: boolean
-  githubToken?: string
-  launchClaudeCode: boolean
-}
-
-// eslint-disable-next-line max-lines-per-function
-export async function runServer(options: RunServerOptions): Promise<void> {
-  if (options.verbose) {
-    consola.level = 5
-    consola.info("Verbose logging enabled")
-  }
-
-  state.accountType = options.accountType
-  if (options.accountType !== "individual") {
-    consola.info(`Using ${options.accountType} plan GitHub account`)
-  }
-
-  state.manualApprove = options.manual
-  state.rateLimitSeconds = options.rateLimit
-  state.rateLimitWait = options.rateLimitWait
-
-  await ensurePaths()
-  await cacheVSCodeVersion()
-
-  if (options.githubToken) {
-    state.githubToken = options.githubToken
-    consola.info("Using provided GitHub token")
-  } else {
-    await setupGitHubToken()
-  }  await setupCopilotToken()
-  await cacheModels()  // Display token information prominently
-  consola.info("=".repeat(50))
-  consola.success("🚀 GitHub Copilot API has been successfully started!")
-  consola.info(`🔑 Current Copilot Token: ${state.copilotToken}`)
-  consola.info(`🌐 Usage Viewer: http://localhost:${options.port}/public/usage.html`)
-  consola.info("=".repeat(50))
-
-  consola.info(
-    `Available models: \n${state.models?.data.map((model) => `- ${model.id}`).join("\n")}`,
-  )
-
-  const serverUrl = `http://localhost:${options.port}`
-
-  if (options.launchClaudeCode) {
-    invariant(state.models, "Models should be loaded by now")
-
-    const selectedModel = await consola.prompt(
-      "Select a model to use with Claude Code",
-      {
-        type: "select",
-        options: state.models.data.map((model) => model.id),
-      },
-    )
-
-    const selectedSmallModel = await consola.prompt(
-      "Select a small model to use with Claude Code",
-      {
-        type: "select",
-        options: state.models.data.map((model) => model.id),
-      },
-    )
-
-    const command = generateEnvScript(
-      {
-        ANTHROPIC_BASE_URL: serverUrl,
-        ANTHROPIC_AUTH_TOKEN: "dummy",
-        ANTHROPIC_MODEL: selectedModel,
-        ANTHROPIC_SMALL_FAST_MODEL: selectedSmallModel,
-      },
-      "claude",
-    )
-
-    clipboard.writeSync(command)
-    consola.success("Copied Claude Code command to clipboard!")
-  }
-
-  serve({
-    fetch: server.fetch as ServerHandler,
-    port: options.port,
-  })
-}
-
-const start = defineCommand({
-  meta: {
-    name: "start",
-    description: "Start the Copilot API server",
-  },
-  args: {
-    port: {
-      alias: "p",
-      type: "string",
-      default: "4141",
-      description: "Port to listen on",
-    },
-    verbose: {
-      alias: "v",
-      type: "boolean",
-      default: false,
-      description: "Enable verbose logging",
-    },
-    "account-type": {
-      alias: "a",
-      type: "string",
-      default: "individual",
-      description: "Account type to use (individual, business, enterprise)",
-    },
-    manual: {
-      type: "boolean",
-      default: false,
-      description: "Enable manual request approval",
-    },
-    "rate-limit": {
-      alias: "r",
-      type: "string",
-      description: "Rate limit in seconds between requests",
-    },
-    wait: {
-      alias: "w",
-      type: "boolean",
-      default: false,
-      description:
-        "Wait instead of error when rate limit is hit. Has no effect if rate limit is not set",
-    },
-    "github-token": {
-      alias: "g",
-      type: "string",
-      description:
-        "Provide GitHub token directly (must be generated using the `auth` subcommand)",
-    },
-    "claude-code": {
-      alias: "c",
-      type: "boolean",
-      default: false,
-      description:
-        "Generate a command to launch Claude Code with Copilot API config",
-    },
-  },
-  run({ args }) {
-    const rateLimitRaw = args["rate-limit"]
-    const rateLimit =
-      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-      rateLimitRaw === undefined ? undefined : Number.parseInt(rateLimitRaw, 10)
-
-    return runServer({
-      port: Number.parseInt(args.port, 10),
-      verbose: args.verbose,
-      accountType: args["account-type"],
-      manual: args.manual,
-      rateLimit,
-      rateLimitWait: Boolean(args.wait),
-      githubToken: args["github-token"],
-      launchClaudeCode: args["claude-code"],
-    })
-  },
-})
+import { start } from "./start"
 
 const main = defineCommand({
   meta: {