feat: unified auth flow with deployment type selection

- Combine separate auth methods into single plugin with select prompts
- Add deployment type selection: GitHub.com (Public) or GitHub Enterprise
- Use conditional prompts to only ask for enterprise URL when needed
- Automatically save enterprise auth to github-copilot-enterprise provider

Author: OlaHulleberg

index.mjs

@@ -1,4 +1,7 @@
-function createCopilotPlugin(client, { providerId, isEnterprise }) {
+/**
+ * @type {import('@opencode-ai/plugin').Plugin}
+ */
+export async function CopilotAuthPlugin({ client }) {
   const CLIENT_ID = "Iv1.b507a08c87ecfe98";
   const HEADERS = {
     "User-Agent": "GitHubCopilotChat/0.35.0",
@@ -23,7 +26,7 @@ function createCopilotPlugin(client, { providerId, isEnterprise }) {
 
   return {
     auth: {
-      provider: providerId,
+      provider: "github-copilot",
       loader: async (getAuth, provider) => {
         let info = await getAuth();
         if (!info || info.type !== "oauth") return {};
@@ -117,197 +120,135 @@ function createCopilotPlugin(client, { providerId, isEnterprise }) {
           },
         };
       },
-      methods: isEnterprise
-        ? [
+      methods: [
+        {
+          type: "custom",
+          label: "Login with GitHub Copilot",
+          prompts: [
             {
-              type: "custom",
-              label: "Login with GitHub Enterprise",
-              prompts: [
+              type: "select",
+              key: "deploymentType",
+              message: "Select GitHub deployment type",
+              options: [
+                {
+                  label: "GitHub.com",
+                  value: "github.com",
+                  hint: "Public",
+                },
                 {
-                  key: "enterpriseUrl",
-                  message: "Enter your GitHub Enterprise URL or domain",
-                  placeholder: "github.company.com or https://github.company.com",
-                  validate: (value) => {
-                    if (!value) return "URL or domain is required";
-                    try {
-                      const url = value.includes("://")
-                        ? new URL(value)
-                        : new URL(`https://${value}`);
-                      if (!url.hostname)
-                        return "Please enter a valid URL or domain";
-                      return undefined;
-                    } catch {
-                      return "Please enter a valid URL (e.g., github.company.com)";
-                    }
-                  },
+                  label: "GitHub Enterprise",
+                  value: "enterprise",
+                  hint: "Data residency or self-hosted",
                 },
               ],
-              async authorize(inputs) {
-                const enterpriseUrl = inputs.enterpriseUrl;
-                const domain = normalizeDomain(enterpriseUrl);
-                const urls = getUrls(domain);
-
-                const deviceResponse = await fetch(urls.DEVICE_CODE_URL, {
-                  method: "POST",
-                  headers: {
-                    Accept: "application/json",
-                    "Content-Type": "application/json",
-                    "User-Agent": "GitHubCopilotChat/0.35.0",
-                  },
-                  body: JSON.stringify({
-                    client_id: CLIENT_ID,
-                    scope: "read:user",
-                  }),
-                });
-
-                if (!deviceResponse.ok) {
-                  return { type: "failed" };
+            },
+            {
+              type: "text",
+              key: "enterpriseUrl",
+              message: "Enter your GitHub Enterprise URL or domain",
+              placeholder: "company.ghe.com or https://company.ghe.com",
+              condition: (inputs) => inputs.deploymentType === "enterprise",
+              validate: (value) => {
+                if (!value) return "URL or domain is required";
+                try {
+                  const url = value.includes("://")
+                    ? new URL(value)
+                    : new URL(`https://${value}`);
+                  if (!url.hostname)
+                    return "Please enter a valid URL or domain";
+                  return undefined;
+                } catch {
+                  return "Please enter a valid URL (e.g., company.ghe.com or https://company.ghe.com)";
                 }
+              },
+            },
+          ],
+          async authorize(inputs) {
+            const deploymentType = inputs.deploymentType;
 
-                const deviceData = await deviceResponse.json();
+            let domain = "github.com";
+            let actualProvider = "github-copilot";
 
-                // Display URL and code for user
-                console.log(`Go to: ${deviceData.verification_uri}`);
-                console.log(`Enter code: ${deviceData.user_code}`);
+            if (deploymentType === "enterprise") {
+              const enterpriseUrl = inputs.enterpriseUrl;
+              domain = normalizeDomain(enterpriseUrl);
+              actualProvider = "github-copilot-enterprise";
+            }
 
-                // Poll for authorization
-                while (true) {
-                  await new Promise((resolve) =>
-                    setTimeout(resolve, (deviceData.interval || 5) * 1000),
-                  );
+            const urls = getUrls(domain);
 
-                  const response = await fetch(urls.ACCESS_TOKEN_URL, {
-                    method: "POST",
-                    headers: {
-                      Accept: "application/json",
-                      "Content-Type": "application/json",
-                      "User-Agent": "GitHubCopilotChat/0.35.0",
-                    },
-                    body: JSON.stringify({
-                      client_id: CLIENT_ID,
-                      device_code: deviceData.device_code,
-                      grant_type:
-                        "urn:ietf:params:oauth:grant-type:device_code",
-                    }),
-                  });
+            const deviceResponse = await fetch(urls.DEVICE_CODE_URL, {
+              method: "POST",
+              headers: {
+                Accept: "application/json",
+                "Content-Type": "application/json",
+                "User-Agent": "GitHubCopilotChat/0.35.0",
+              },
+              body: JSON.stringify({
+                client_id: CLIENT_ID,
+                scope: "read:user",
+              }),
+            });
 
-                  if (!response.ok) return { type: "failed" };
+            if (!deviceResponse.ok) {
+              return { type: "failed" };
+            }
 
-                  const data = await response.json();
+            const deviceData = await deviceResponse.json();
 
-                  if (data.access_token) {
-                    return {
-                      type: "success",
-                      auth_type: "oauth",
-                      refresh: data.access_token,
-                      access: "",
-                      expires: 0,
-                      enterpriseUrl: domain,
-                    };
-                  }
+            console.log(`Go to: ${deviceData.verification_uri}`);
+            console.log(`Enter code: ${deviceData.user_code}`);
 
-                  if (data.error === "authorization_pending") {
-                    continue;
-                  }
+            while (true) {
+              await new Promise((resolve) =>
+                setTimeout(resolve, (deviceData.interval || 5) * 1000),
+              );
 
-                  if (data.error) return { type: "failed" };
-                }
-              },
-            },
-          ]
-        : [
-            {
-              type: "oauth",
-              label: "Login with GitHub",
-              authorize: async () => {
-                const urls = getUrls("github.com");
+              const response = await fetch(urls.ACCESS_TOKEN_URL, {
+                method: "POST",
+                headers: {
+                  Accept: "application/json",
+                  "Content-Type": "application/json",
+                  "User-Agent": "GitHubCopilotChat/0.35.0",
+                },
+                body: JSON.stringify({
+                  client_id: CLIENT_ID,
+                  device_code: deviceData.device_code,
+                  grant_type:
+                    "urn:ietf:params:oauth:grant-type:device_code",
+                }),
+              });
 
-                const deviceResponse = await fetch(urls.DEVICE_CODE_URL, {
-                  method: "POST",
-                  headers: {
-                    Accept: "application/json",
-                    "Content-Type": "application/json",
-                    "User-Agent": "GitHubCopilotChat/0.35.0",
-                  },
-                  body: JSON.stringify({
-                    client_id: CLIENT_ID,
-                    scope: "read:user",
-                  }),
-                });
-                const deviceData = await deviceResponse.json();
-                return {
-                  url: deviceData.verification_uri,
-                  instructions: `Enter code: ${deviceData.user_code}`,
-                  method: "auto",
-                  callback: async () => {
-                    while (true) {
-                      const response = await fetch(urls.ACCESS_TOKEN_URL, {
-                        method: "POST",
-                        headers: {
-                          Accept: "application/json",
-                          "Content-Type": "application/json",
-                          "User-Agent": "GitHubCopilotChat/0.35.0",
-                        },
-                        body: JSON.stringify({
-                          client_id: CLIENT_ID,
-                          device_code: deviceData.device_code,
-                          grant_type:
-                            "urn:ietf:params:oauth:grant-type:device_code",
-                        }),
-                      });
+              if (!response.ok) return { type: "failed" };
 
-                      if (!response.ok) return { type: "failed" };
+              const data = await response.json();
 
-                      const data = await response.json();
+              if (data.access_token) {
+                const result = {
+                  type: "success",
+                  auth_type: "oauth",
+                  refresh: data.access_token,
+                  access: "",
+                  expires: 0,
+                };
 
-                      if (data.access_token) {
-                        return {
-                          type: "success",
-                          refresh: data.access_token,
-                          access: "",
-                          expires: 0,
-                        };
-                      }
+                if (actualProvider === "github-copilot-enterprise") {
+                  result.provider = "github-copilot-enterprise";
+                  result.enterpriseUrl = domain;
+                }
 
-                      if (data.error === "authorization_pending") {
-                        await new Promise((resolve) =>
-                          setTimeout(resolve, deviceData.interval * 1000),
-                        );
-                        continue;
-                      }
+                return result;
+              }
 
-                      if (data.error) return { type: "failed" };
+              if (data.error === "authorization_pending") {
+                continue;
+              }
 
-                      await new Promise((resolve) =>
-                        setTimeout(resolve, deviceData.interval * 1000),
-                      );
-                      continue;
-                    }
-                  },
-                };
-              },
-            },
-          ],
+              if (data.error) return { type: "failed" };
+            }
+          },
+        },
+      ],
     },
   };
 }
-
-/**
- * @type {import('@opencode-ai/plugin').Plugin}
- */
-export async function CopilotAuthPlugin({ client }) {
-  return createCopilotPlugin(client, {
-    providerId: "github-copilot",
-    isEnterprise: false,
-  });
-}
-
-/**
- * @type {import('@opencode-ai/plugin').Plugin}
- */
-export async function CopilotEnterpriseAuthPlugin({ client }) {
-  return createCopilotPlugin(client, {
-    providerId: "github-copilot-enterprise",
-    isEnterprise: true,
-  });
-}