bashio 1.0.0 → 1.1.1

package/dist/index.js

@@ -20,7 +20,10 @@ import { join } from "path";
 import { z } from "zod";
 var ProviderName = z.enum([
   "claude",
+  "claude-subscription",
   "openai",
+  "chatgpt-subscription",
+  "copilot",
   "ollama",
   "openrouter"
 ]);
@@ -36,10 +39,41 @@ var LocalCredentials = z.object({
   type: z.literal("local"),
   host: z.string().default("http://localhost:11434")
 });
+var ClaudeSubscriptionCredentials = z.object({
+  type: z.literal("claude_subscription"),
+  accessToken: z.string(),
+  refreshToken: z.string(),
+  expiresAt: z.number(),
+  // Unix timestamp in ms
+  email: z.string().optional()
+});
+var ChatGPTSubscriptionCredentials = z.object({
+  type: z.literal("chatgpt_subscription"),
+  accessToken: z.string(),
+  refreshToken: z.string().optional(),
+  expiresAt: z.number().optional(),
+  // Unix timestamp in ms
+  accountId: z.string().optional()
+  // ChatGPT account ID for API requests
+});
+var CopilotCredentials = z.object({
+  type: z.literal("copilot"),
+  githubToken: z.string(),
+  // GitHub OAuth access token (gho_xxx)
+  copilotToken: z.string(),
+  // Copilot API token (short-lived)
+  copilotTokenExpiresAt: z.number(),
+  // Unix timestamp in ms
+  apiEndpoint: z.string().optional()
+  // Derived from token (api.individual/business.githubcopilot.com)
+});
 var Credentials = z.discriminatedUnion("type", [
   SessionCredentials,
   ApiKeyCredentials,
-  LocalCredentials
+  LocalCredentials,
+  ClaudeSubscriptionCredentials,
+  ChatGPTSubscriptionCredentials,
+  CopilotCredentials
 ]);
 var Settings = z.object({
   confirmBeforeExecute: z.boolean().default(true),
@@ -48,13 +82,24 @@ var Settings = z.object({
   historyMaxEntries: z.number().default(2e3),
   autoConfirmShortcuts: z.boolean().default(false)
 });
-var Config = z.object({
-  version: z.number().default(1),
+var ConfigV1 = z.object({
+  version: z.literal(1).default(1),
   provider: ProviderName,
   model: z.string(),
   credentials: Credentials,
   settings: Settings.optional()
 });
+var ProviderSettings = z.object({
+  model: z.string(),
+  credentials: Credentials
+});
+var ConfigV2 = z.object({
+  version: z.literal(2),
+  activeProvider: ProviderName,
+  providers: z.record(z.string(), ProviderSettings),
+  settings: Settings.optional()
+});
+var Config = z.union([ConfigV2, ConfigV1]);
 var ShortcutDefinition = z.object({
   template: z.string(),
   args: z.array(z.string()).default([]),
@@ -98,6 +143,19 @@ function ensureConfigDir() {
 function configExists() {
   return existsSync(CONFIG_FILE);
 }
+function migrateV1toV2(v1) {
+  return {
+    version: 2,
+    activeProvider: v1.provider,
+    providers: {
+      [v1.provider]: {
+        model: v1.model,
+        credentials: v1.credentials
+      }
+    },
+    settings: v1.settings
+  };
+}
 function loadConfig() {
   if (!configExists()) {
     return null;
@@ -105,7 +163,17 @@ function loadConfig() {
   try {
     const raw = readFileSync(CONFIG_FILE, "utf-8");
     const data = JSON.parse(raw);
-    return Config.parse(data);
+    const v2Result = ConfigV2.safeParse(data);
+    if (v2Result.success) {
+      return v2Result.data;
+    }
+    const v1Result = ConfigV1.safeParse(data);
+    if (v1Result.success) {
+      const migrated = migrateV1toV2(v1Result.data);
+      saveConfig(migrated);
+      return migrated;
+    }
+    return null;
   } catch {
     return null;
   }
@@ -122,6 +190,19 @@ function getConfigPath() {
 function getConfigDir() {
   return CONFIG_DIR;
 }
+function isProviderConfigured(config, provider) {
+  return provider in config.providers;
+}
+function setProviderConfig(config, provider, settings, setActive = true) {
+  return {
+    ...config,
+    activeProvider: setActive ? provider : config.activeProvider,
+    providers: {
+      ...config.providers,
+      [provider]: settings
+    }
+  };
+}
 
 // src/core/database.ts
 import { chmodSync as chmodSync2, existsSync as existsSync2 } from "fs";
@@ -587,6 +668,392 @@ import pc4 from "picocolors";
 import { input as input3, password, select } from "@inquirer/prompts";
 import pc3 from "picocolors";
 
+// src/core/oauth.ts
+import * as crypto from "crypto";
+import * as http from "http";
+import { URL as URL2 } from "url";
+var CLAUDE_OAUTH_CONFIG = {
+  clientId: "9d1c250a-e61b-44d9-88ed-5944d1962f5e",
+  authorizationUrl: "https://claude.ai/oauth/authorize",
+  tokenUrl: "https://console.anthropic.com/v1/oauth/token",
+  redirectUri: "http://localhost:8765/callback",
+  scopes: "org:create_api_key user:profile user:inference",
+  callbackPort: 8765
+};
+var COPILOT_OAUTH_CONFIG = {
+  clientId: "Iv1.b507a08c87ecfe98",
+  // Official GitHub Copilot client ID
+  deviceCodeUrl: "https://github.com/login/device/code",
+  accessTokenUrl: "https://github.com/login/oauth/access_token",
+  copilotTokenUrl: "https://api.github.com/copilot_internal/v2/token",
+  apiEndpoint: "https://api.githubcopilot.com/chat/completions",
+  scope: "read:user"
+};
+var CHATGPT_OAUTH_CONFIG = {
+  clientId: "app_EMoamEEZ73f0CkXaXp7hrann",
+  // Official Codex CLI client ID
+  authorizationUrl: "https://auth.openai.com/oauth/authorize",
+  tokenUrl: "https://auth.openai.com/oauth/token",
+  redirectUri: "http://localhost:1455/auth/callback",
+  scopes: "openid profile email offline_access",
+  callbackPort: 1455,
+  audience: "https://api.openai.com/v1",
+  // Backend API endpoint (subscription OAuth uses this, NOT api.openai.com)
+  apiEndpoint: "https://chatgpt.com/backend-api/codex/responses"
+};
+function generateCodeVerifier() {
+  return crypto.randomBytes(32).toString("base64url");
+}
+function generateCodeChallenge(verifier) {
+  return crypto.createHash("sha256").update(verifier).digest("base64url");
+}
+function generateState() {
+  return crypto.randomBytes(16).toString("hex");
+}
+function generatePKCE() {
+  const codeVerifier = generateCodeVerifier();
+  const codeChallenge = generateCodeChallenge(codeVerifier);
+  const state = generateState();
+  return { codeVerifier, codeChallenge, state };
+}
+function buildClaudeAuthUrl(pkce) {
+  const params = new URLSearchParams({
+    client_id: CLAUDE_OAUTH_CONFIG.clientId,
+    redirect_uri: CLAUDE_OAUTH_CONFIG.redirectUri,
+    scope: CLAUDE_OAUTH_CONFIG.scopes,
+    code_challenge: pkce.codeChallenge,
+    code_challenge_method: "S256",
+    response_type: "code",
+    state: pkce.state
+  });
+  return `${CLAUDE_OAUTH_CONFIG.authorizationUrl}?${params.toString()}`;
+}
+async function exchangeClaudeCode(code, codeVerifier, state) {
+  const body = {
+    code,
+    state,
+    grant_type: "authorization_code",
+    client_id: CLAUDE_OAUTH_CONFIG.clientId,
+    redirect_uri: CLAUDE_OAUTH_CONFIG.redirectUri,
+    code_verifier: codeVerifier
+  };
+  const response = await fetch(CLAUDE_OAUTH_CONFIG.tokenUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Claude token exchange failed: ${response.status} - ${errorText}`
+    );
+  }
+  const data = await response.json();
+  if (!data.refresh_token) {
+    throw new Error("Claude token exchange did not return a refresh_token");
+  }
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token,
+    expiresAt: Date.now() + data.expires_in * 1e3,
+    email: data.email
+  };
+}
+async function refreshClaudeToken(refreshToken) {
+  const body = {
+    grant_type: "refresh_token",
+    client_id: CLAUDE_OAUTH_CONFIG.clientId,
+    refresh_token: refreshToken
+  };
+  const response = await fetch(CLAUDE_OAUTH_CONFIG.tokenUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Claude token refresh failed: ${response.status} - ${errorText}`
+    );
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token || refreshToken,
+    expiresAt: Date.now() + data.expires_in * 1e3,
+    email: data.email
+  };
+}
+function isClaudeTokenExpired(expiresAt) {
+  const bufferMs = 5 * 60 * 1e3;
+  return Date.now() >= expiresAt - bufferMs;
+}
+function parseJWTClaims(token) {
+  try {
+    const parts = token.split(".");
+    if (parts.length !== 3) return null;
+    const payload = parts[1];
+    const decoded = Buffer.from(payload, "base64url").toString("utf-8");
+    return JSON.parse(decoded);
+  } catch {
+    return null;
+  }
+}
+function extractAccountIdFromToken(accessToken, idToken) {
+  const tokens = idToken ? [idToken, accessToken] : [accessToken];
+  for (const token of tokens) {
+    const claims = parseJWTClaims(token);
+    if (!claims) continue;
+    const accountId = claims.chatgpt_account_id || claims["https://api.openai.com/auth"]?.chatgpt_account_id || claims.organizations?.[0]?.id;
+    if (accountId) return accountId;
+  }
+  return void 0;
+}
+function buildChatGPTAuthUrl(pkce) {
+  const params = new URLSearchParams({
+    client_id: CHATGPT_OAUTH_CONFIG.clientId,
+    redirect_uri: CHATGPT_OAUTH_CONFIG.redirectUri,
+    scope: CHATGPT_OAUTH_CONFIG.scopes,
+    code_challenge: pkce.codeChallenge,
+    code_challenge_method: "S256",
+    response_type: "code",
+    state: pkce.state,
+    audience: CHATGPT_OAUTH_CONFIG.audience
+  });
+  return `${CHATGPT_OAUTH_CONFIG.authorizationUrl}?${params.toString()}`;
+}
+async function exchangeChatGPTCode(code, codeVerifier) {
+  const body = new URLSearchParams({
+    grant_type: "authorization_code",
+    client_id: CHATGPT_OAUTH_CONFIG.clientId,
+    code,
+    redirect_uri: CHATGPT_OAUTH_CONFIG.redirectUri,
+    code_verifier: codeVerifier
+  });
+  const response = await fetch(CHATGPT_OAUTH_CONFIG.tokenUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: body.toString()
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `ChatGPT token exchange failed: ${response.status} - ${errorText}`
+    );
+  }
+  const data = await response.json();
+  const accountId = extractAccountIdFromToken(data.access_token, data.id_token);
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token || "",
+    expiresAt: data.expires_in ? Date.now() + data.expires_in * 1e3 : 0,
+    accountId
+  };
+}
+async function refreshChatGPTToken(refreshToken) {
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    client_id: CHATGPT_OAUTH_CONFIG.clientId,
+    refresh_token: refreshToken
+  });
+  const response = await fetch(CHATGPT_OAUTH_CONFIG.tokenUrl, {
+    method: "POST",
+    headers: { "Content-Type": "application/x-www-form-urlencoded" },
+    body: body.toString()
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `ChatGPT token refresh failed: ${response.status} - ${errorText}`
+    );
+  }
+  const data = await response.json();
+  return {
+    accessToken: data.access_token,
+    refreshToken: data.refresh_token || refreshToken,
+    expiresAt: data.expires_in ? Date.now() + data.expires_in * 1e3 : 0
+  };
+}
+function startCallbackServer(port, expectedState, timeoutMs = 5 * 60 * 1e3) {
+  return new Promise((resolve, reject) => {
+    const server = http.createServer((req, res) => {
+      const parsedUrl = new URL2(req.url || "", `http://localhost:${port}`);
+      if (parsedUrl.pathname !== "/callback" && parsedUrl.pathname !== "/auth/callback") {
+        res.writeHead(404);
+        res.end("Not Found");
+        return;
+      }
+      const code = parsedUrl.searchParams.get("code");
+      const state = parsedUrl.searchParams.get("state");
+      const error = parsedUrl.searchParams.get("error");
+      if (error) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(
+          `<html><body><h1>Authentication Failed</h1><p>${error}</p></body></html>`
+        );
+        server.close();
+        reject(new Error(`OAuth error: ${error}`));
+        return;
+      }
+      if (!code || !state) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end("<html><body><h1>Missing Parameters</h1></body></html>");
+        server.close();
+        reject(new Error("Missing code or state parameter"));
+        return;
+      }
+      if (state !== expectedState) {
+        res.writeHead(400, { "Content-Type": "text/html" });
+        res.end(
+          "<html><body><h1>Invalid State</h1><p>Possible CSRF attack.</p></body></html>"
+        );
+        server.close();
+        reject(new Error("State mismatch - possible CSRF attack"));
+        return;
+      }
+      res.writeHead(200, { "Content-Type": "text/html" });
+      res.end(`
+        <!DOCTYPE html>
+        <html>
+        <head><title>Authentication Successful</title></head>
+        <body style="font-family: system-ui; text-align: center; padding: 50px;">
+          <h1>Authentication Successful!</h1>
+          <p>You can close this window and return to your terminal.</p>
+          <script>setTimeout(() => window.close(), 2000);</script>
+        </body>
+        </html>
+      `);
+      server.close();
+      resolve({ code, state });
+    });
+    server.on("error", (err) => {
+      if (err.code === "EADDRINUSE") {
+        reject(
+          new Error(
+            `Port ${port} is already in use. Close other applications using this port.`
+          )
+        );
+      } else {
+        reject(err);
+      }
+    });
+    const timeout = setTimeout(() => {
+      server.close();
+      reject(new Error("Authentication timed out after 5 minutes"));
+    }, timeoutMs);
+    server.on("close", () => clearTimeout(timeout));
+    server.listen(port, "127.0.0.1");
+  });
+}
+async function requestCopilotDeviceCode() {
+  const body = new URLSearchParams({
+    client_id: COPILOT_OAUTH_CONFIG.clientId,
+    scope: COPILOT_OAUTH_CONFIG.scope
+  });
+  const response = await fetch(COPILOT_OAUTH_CONFIG.deviceCodeUrl, {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/x-www-form-urlencoded"
+    },
+    body: body.toString()
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(
+      `Failed to request device code: ${response.status} - ${errorText}`
+    );
+  }
+  return await response.json();
+}
+async function pollForCopilotAccessToken(deviceCode, intervalMs, expiresAt) {
+  const body = new URLSearchParams({
+    client_id: COPILOT_OAUTH_CONFIG.clientId,
+    device_code: deviceCode,
+    grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+  });
+  while (Date.now() < expiresAt) {
+    const response = await fetch(COPILOT_OAUTH_CONFIG.accessTokenUrl, {
+      method: "POST",
+      headers: {
+        Accept: "application/json",
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: body.toString()
+    });
+    const data = await response.json();
+    if (data.access_token) {
+      return data.access_token;
+    }
+    if (data.error === "authorization_pending") {
+      await new Promise((r) => setTimeout(r, intervalMs));
+      continue;
+    }
+    if (data.error === "slow_down") {
+      await new Promise((r) => setTimeout(r, intervalMs + 5e3));
+      continue;
+    }
+    if (data.error === "expired_token") {
+      throw new Error("Device code expired. Please try again.");
+    }
+    if (data.error === "access_denied") {
+      throw new Error("Access denied. User cancelled authorization.");
+    }
+    throw new Error(`GitHub OAuth error: ${data.error || "Unknown error"}`);
+  }
+  throw new Error("Authorization timed out. Please try again.");
+}
+async function exchangeGitHubTokenForCopilot(githubToken) {
+  const response = await fetch(COPILOT_OAUTH_CONFIG.copilotTokenUrl, {
+    method: "GET",
+    headers: {
+      Accept: "application/json",
+      Authorization: `Bearer ${githubToken}`
+    }
+  });
+  if (!response.ok) {
+    const errorText = await response.text();
+    if (response.status === 401) {
+      throw new Error("GitHub token is invalid or expired.");
+    }
+    if (response.status === 403) {
+      throw new Error(
+        "You do not have access to GitHub Copilot. Please ensure you have an active Copilot subscription."
+      );
+    }
+    throw new Error(
+      `Failed to get Copilot token: ${response.status} - ${errorText}`
+    );
+  }
+  return await response.json();
+}
+function parseCopilotToken(token) {
+  let expiresAt = Date.now() + 30 * 60 * 1e3;
+  let apiEndpoint = COPILOT_OAUTH_CONFIG.apiEndpoint;
+  const pairs = token.split(";");
+  for (const pair of pairs) {
+    const [key, value] = pair.split("=");
+    if (key?.trim() === "exp" && value) {
+      expiresAt = Number.parseInt(value.trim(), 10) * 1e3;
+    }
+    if (key?.trim() === "proxy-ep" && value) {
+      let proxyUrl = value.trim();
+      if (!proxyUrl.startsWith("http")) {
+        proxyUrl = `https://${proxyUrl}`;
+      }
+      apiEndpoint = proxyUrl.replace(/\/\/proxy\./i, "//api.");
+      if (!apiEndpoint.includes("/chat/completions")) {
+        apiEndpoint = `${apiEndpoint}/chat/completions`;
+      }
+    }
+  }
+  return { expiresAt, apiEndpoint };
+}
+function isCopilotTokenExpired(expiresAt) {
+  const bufferMs = 5 * 60 * 1e3;
+  return Date.now() >= expiresAt - bufferMs;
+}
+
 // src/providers/base.ts
 var SYSTEM_PROMPT_GENERATE = `You are a shell command generator for macOS/Linux terminals.
 Given a natural language description, return ONLY the shell command.
@@ -602,6 +1069,182 @@ Explain the given shell command in simple terms.
 Break down each part of the command concisely.
 Format as a simple list without markdown.`;
 
+// src/providers/chatgpt-subscription.ts
+var ChatGPTSubscriptionProvider = class {
+  name = "ChatGPT (Subscription)";
+  model;
+  accessToken;
+  refreshToken;
+  expiresAt;
+  accountId;
+  constructor(config) {
+    this.model = config.model;
+    if (config.credentials.type === "chatgpt_subscription") {
+      this.accessToken = config.credentials.accessToken;
+      this.refreshToken = config.credentials.refreshToken;
+      this.expiresAt = config.credentials.expiresAt;
+      this.accountId = config.credentials.accountId;
+      if (!this.accountId) {
+        this.accountId = extractAccountIdFromToken(this.accessToken);
+      }
+    } else {
+      throw new Error("ChatGPT Subscription requires subscription credentials");
+    }
+  }
+  isTokenExpired() {
+    if (!this.expiresAt) return false;
+    const bufferMs = 5 * 60 * 1e3;
+    return Date.now() >= this.expiresAt - bufferMs;
+  }
+  async ensureValidToken() {
+    if (this.isTokenExpired() && this.refreshToken) {
+      try {
+        const newTokens = await refreshChatGPTToken(this.refreshToken);
+        this.accessToken = newTokens.accessToken;
+        this.refreshToken = newTokens.refreshToken || this.refreshToken;
+        this.expiresAt = newTokens.expiresAt || this.expiresAt;
+        if (newTokens.accountId) {
+          this.accountId = newTokens.accountId;
+        } else if (!this.accountId) {
+          this.accountId = extractAccountIdFromToken(this.accessToken);
+        }
+        const currentConfig = loadConfig();
+        const providerSettings = currentConfig?.providers["chatgpt-subscription"];
+        if (currentConfig && providerSettings?.credentials.type === "chatgpt_subscription") {
+          providerSettings.credentials.accessToken = newTokens.accessToken;
+          if (newTokens.refreshToken) {
+            providerSettings.credentials.refreshToken = newTokens.refreshToken;
+          }
+          if (newTokens.expiresAt) {
+            providerSettings.credentials.expiresAt = newTokens.expiresAt;
+          }
+          if (this.accountId) {
+            providerSettings.credentials.accountId = this.accountId;
+          }
+          saveConfig(currentConfig);
+        }
+      } catch (error) {
+        throw new Error(
+          `Token refresh failed. Please re-authenticate with: b --auth
+Error: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+    return this.accessToken;
+  }
+  async call(systemPrompt, userMessage) {
+    const token = await this.ensureValidToken();
+    const requestBody = {
+      model: this.model,
+      instructions: systemPrompt,
+      input: [
+        {
+          type: "message",
+          role: "user",
+          content: [{ type: "input_text", text: userMessage }]
+        }
+      ],
+      store: false,
+      stream: true
+    };
+    const headers = {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${token}`,
+      "OpenAI-Beta": "responses=experimental",
+      originator: "bashio"
+    };
+    if (this.accountId) {
+      headers["ChatGPT-Account-Id"] = this.accountId;
+    }
+    const response = await fetch(CHATGPT_OAUTH_CONFIG.apiEndpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      if (response.status === 401) {
+        throw new Error(
+          "Authentication failed. Please re-authenticate with: b --auth"
+        );
+      }
+      if (response.status === 403) {
+        throw new Error(
+          `Access forbidden. Your ChatGPT subscription may not have access to this model.
+Error: ${errorText}`
+        );
+      }
+      throw new Error(`ChatGPT API error: ${response.status} - ${errorText}`);
+    }
+    return this.parseStreamingResponse(response);
+  }
+  async parseStreamingResponse(response) {
+    if (!response.body) {
+      throw new Error("No response body from ChatGPT");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder("utf-8");
+    let buffer = "";
+    let fullText = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim() || !line.startsWith("data:")) continue;
+          const data = line.substring(5).trim();
+          if (data === "[DONE]") {
+            return fullText.trim();
+          }
+          try {
+            const chunk = JSON.parse(data);
+            if (chunk.type === "response.output_text.delta" && chunk.delta) {
+              fullText += chunk.delta;
+            } else if (chunk.choices?.[0]?.delta?.content) {
+              fullText += chunk.choices[0].delta.content;
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
+    }
+    if (!fullText) {
+      throw new Error("No response content from ChatGPT");
+    }
+    return fullText.trim();
+  }
+  async generateCommand(query, context) {
+    const userMessage = context ? `Context: ${context}
+
+Task: ${query}` : query;
+    return this.call(SYSTEM_PROMPT_GENERATE, userMessage);
+  }
+  async explainCommand(command) {
+    return this.call(SYSTEM_PROMPT_EXPLAIN, `Explain this command: ${command}`);
+  }
+  async validateCredentials() {
+    try {
+      const token = await this.ensureValidToken();
+      return !!token && token.length > 0;
+    } catch {
+      return false;
+    }
+  }
+};
+var CHATGPT_SUBSCRIPTION_MODELS = [
+  { value: "gpt-5.2-codex", label: "GPT-5.2-Codex (recommended for coding)" },
+  { value: "gpt-5.2", label: "GPT-5.2 (most intelligent)" },
+  { value: "gpt-5.1-codex-max", label: "GPT-5.1-Codex-Max (long tasks)" },
+  { value: "gpt-5.1-codex-mini", label: "GPT-5.1-Codex-Mini (fast)" },
+  { value: "o4-mini", label: "o4-mini (reasoning)" },
+  { value: "gpt-4o", label: "GPT-4o (legacy)" }
+];
+
 // src/providers/claude.ts
 var ClaudeProvider = class {
   name = "Claude";
@@ -636,18 +1279,357 @@ var ClaudeProvider = class {
       })
     });
     if (!response.ok) {
-      const error = await response.text();
-      throw new Error(`Claude API error: ${response.status} - ${error}`);
+      const error = await response.text();
+      throw new Error(`Claude API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Claude API error: ${data.error.message}`);
+    }
+    const textContent = data.content.find((c) => c.type === "text");
+    if (!textContent) {
+      throw new Error("No text response from Claude");
+    }
+    return textContent.text.trim();
+  }
+  async generateCommand(query, context) {
+    const userMessage = context ? `Context: ${context}
+
+Task: ${query}` : query;
+    return this.call(SYSTEM_PROMPT_GENERATE, userMessage);
+  }
+  async explainCommand(command) {
+    return this.call(SYSTEM_PROMPT_EXPLAIN, `Explain this command: ${command}`);
+  }
+  async validateCredentials() {
+    try {
+      const response = await fetch("https://api.anthropic.com/v1/messages", {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "x-api-key": this.apiKey,
+          "anthropic-version": "2023-06-01"
+        },
+        body: JSON.stringify({
+          model: this.model,
+          max_tokens: 10,
+          messages: [{ role: "user", content: "hi" }]
+        })
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+var CLAUDE_MODELS = [
+  {
+    value: "claude-opus-4-5-20251101",
+    label: "Claude Opus 4.5 (most intelligent)"
+  },
+  {
+    value: "claude-sonnet-4-5-20250929",
+    label: "Claude Sonnet 4.5 (recommended)"
+  },
+  { value: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5 (fast)" },
+  { value: "claude-sonnet-4-20250514", label: "Claude Sonnet 4" },
+  { value: "claude-opus-4-20250514", label: "Claude Opus 4" }
+];
+
+// src/providers/claude-subscription.ts
+var CLAUDE_CODE_PREFIX = "You are Claude Code, Anthropic's official CLI for Claude.";
+var CLAUDE_CODE_BETAS = [
+  "oauth-2025-04-20",
+  "claude-code-20250219",
+  "interleaved-thinking-2025-05-14",
+  "fine-grained-tool-streaming-2025-05-14"
+].join(",");
+var ClaudeSubscriptionProvider = class {
+  name = "Claude (Subscription)";
+  model;
+  accessToken;
+  refreshToken;
+  expiresAt;
+  constructor(config) {
+    this.model = config.model;
+    if (config.credentials.type === "claude_subscription") {
+      this.accessToken = config.credentials.accessToken;
+      this.refreshToken = config.credentials.refreshToken;
+      this.expiresAt = config.credentials.expiresAt;
+    } else {
+      throw new Error("Claude Subscription requires subscription credentials");
+    }
+  }
+  async ensureValidToken() {
+    if (isClaudeTokenExpired(this.expiresAt)) {
+      try {
+        const newTokens = await refreshClaudeToken(this.refreshToken);
+        this.accessToken = newTokens.accessToken;
+        this.refreshToken = newTokens.refreshToken;
+        this.expiresAt = newTokens.expiresAt;
+        const currentConfig = loadConfig();
+        const providerSettings = currentConfig?.providers["claude-subscription"];
+        if (currentConfig && providerSettings?.credentials.type === "claude_subscription") {
+          providerSettings.credentials.accessToken = newTokens.accessToken;
+          providerSettings.credentials.refreshToken = newTokens.refreshToken;
+          providerSettings.credentials.expiresAt = newTokens.expiresAt;
+          saveConfig(currentConfig);
+        }
+      } catch (error) {
+        throw new Error(
+          `Token refresh failed. Please re-authenticate with: b --auth
+Error: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+    return this.accessToken;
+  }
+  async call(systemPrompt, userMessage) {
+    const token = await this.ensureValidToken();
+    const messages = [
+      { role: "user", content: userMessage }
+    ];
+    const systemBlocks = [
+      { type: "text", text: CLAUDE_CODE_PREFIX },
+      { type: "text", text: systemPrompt }
+    ];
+    const headers = {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json",
+      "anthropic-version": "2023-06-01",
+      "anthropic-beta": CLAUDE_CODE_BETAS,
+      "anthropic-dangerous-direct-browser-access": "true",
+      "user-agent": "claude-cli/1.0.119 (external, cli)",
+      "x-app": "cli",
+      accept: "application/json"
+    };
+    const response = await fetch(
+      "https://api.anthropic.com/v1/messages?beta=true",
+      {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+          model: this.model,
+          max_tokens: 1024,
+          system: systemBlocks,
+          messages
+        })
+      }
+    );
+    if (!response.ok) {
+      const error = await response.text();
+      if (response.status === 401) {
+        throw new Error(
+          "Authentication failed. Please re-authenticate with: b --auth"
+        );
+      }
+      throw new Error(`Claude API error: ${response.status} - ${error}`);
+    }
+    const data = await response.json();
+    if (data.error) {
+      throw new Error(`Claude API error: ${data.error.message}`);
+    }
+    const textContent = data.content.find((c) => c.type === "text");
+    if (!textContent) {
+      throw new Error("No text response from Claude");
+    }
+    return textContent.text.trim();
+  }
+  async generateCommand(query, context) {
+    const userMessage = context ? `Context: ${context}
+
+Task: ${query}` : query;
+    return this.call(SYSTEM_PROMPT_GENERATE, userMessage);
+  }
+  async explainCommand(command) {
+    return this.call(SYSTEM_PROMPT_EXPLAIN, `Explain this command: ${command}`);
+  }
+  async validateCredentials() {
+    try {
+      const token = await this.ensureValidToken();
+      const headers = {
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json",
+        "anthropic-version": "2023-06-01",
+        "anthropic-beta": CLAUDE_CODE_BETAS,
+        "anthropic-dangerous-direct-browser-access": "true",
+        "user-agent": "claude-cli/1.0.119 (external, cli)",
+        "x-app": "cli",
+        accept: "application/json"
+      };
+      const response = await fetch(
+        "https://api.anthropic.com/v1/messages?beta=true",
+        {
+          method: "POST",
+          headers,
+          body: JSON.stringify({
+            model: this.model,
+            max_tokens: 10,
+            system: [{ type: "text", text: CLAUDE_CODE_PREFIX }],
+            messages: [{ role: "user", content: "hi" }]
+          })
+        }
+      );
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+var CLAUDE_SUBSCRIPTION_MODELS = [
+  {
+    value: "claude-opus-4-5-20251101",
+    label: "Claude Opus 4.5 (most intelligent)"
+  },
+  {
+    value: "claude-sonnet-4-5-20250929",
+    label: "Claude Sonnet 4.5 (recommended)"
+  },
+  { value: "claude-haiku-4-5-20251001", label: "Claude Haiku 4.5 (fast)" },
+  { value: "claude-sonnet-4-20250514", label: "Claude Sonnet 4" },
+  { value: "claude-opus-4-20250514", label: "Claude Opus 4 (Max plan only)" }
+];
+
+// src/providers/copilot.ts
+var CopilotProvider = class {
+  name = "GitHub Copilot";
+  model;
+  githubToken;
+  copilotToken;
+  copilotTokenExpiresAt;
+  apiEndpoint;
+  constructor(config) {
+    this.model = config.model;
+    if (config.credentials.type === "copilot") {
+      this.githubToken = config.credentials.githubToken;
+      this.copilotToken = config.credentials.copilotToken;
+      this.copilotTokenExpiresAt = config.credentials.copilotTokenExpiresAt;
+      this.apiEndpoint = this.normalizeEndpoint(
+        config.credentials.apiEndpoint || COPILOT_OAUTH_CONFIG.apiEndpoint
+      );
+    } else {
+      throw new Error("Copilot requires copilot credentials");
+    }
+  }
+  normalizeEndpoint(endpoint) {
+    let url = endpoint;
+    if (!url.startsWith("http")) {
+      url = `https://${url}`;
+    }
+    url = url.replace(/\/\/proxy\./i, "//api.");
+    if (!url.includes("/chat/completions")) {
+      url = `${url}/chat/completions`;
+    }
+    return url;
+  }
+  async ensureValidToken() {
+    if (isCopilotTokenExpired(this.copilotTokenExpiresAt)) {
+      try {
+        const newTokenData = await exchangeGitHubTokenForCopilot(
+          this.githubToken
+        );
+        this.copilotToken = newTokenData.token;
+        const parsed = parseCopilotToken(newTokenData.token);
+        this.copilotTokenExpiresAt = parsed.expiresAt;
+        this.apiEndpoint = parsed.apiEndpoint;
+        const currentConfig = loadConfig();
+        const providerSettings = currentConfig?.providers.copilot;
+        if (currentConfig && providerSettings?.credentials.type === "copilot") {
+          providerSettings.credentials.copilotToken = newTokenData.token;
+          providerSettings.credentials.copilotTokenExpiresAt = parsed.expiresAt;
+          providerSettings.credentials.apiEndpoint = parsed.apiEndpoint;
+          saveConfig(currentConfig);
+        }
+      } catch (error) {
+        throw new Error(
+          `Copilot token refresh failed. Please re-authenticate with: b --auth
+Error: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+    return this.copilotToken;
+  }
+  async call(systemPrompt, userMessage) {
+    const token = await this.ensureValidToken();
+    const requestBody = {
+      model: this.model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userMessage }
+      ],
+      temperature: 0.1,
+      top_p: 1,
+      n: 1,
+      stream: true
+    };
+    const headers = {
+      "Content-Type": "application/json",
+      Accept: "application/json",
+      Authorization: `Bearer ${token}`,
+      "User-Agent": "GitHubCopilotChat/0.35.0",
+      "Editor-Version": "vscode/1.107.0",
+      "Editor-Plugin-Version": "copilot-chat/0.35.0",
+      "Copilot-Integration-Id": "vscode-chat"
+    };
+    const response = await fetch(this.apiEndpoint, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(requestBody)
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      if (response.status === 401) {
+        throw new Error(
+          "Authentication failed. Please re-authenticate with: b --auth"
+        );
+      }
+      if (response.status === 403) {
+        throw new Error(
+          "Access forbidden. Please ensure you have an active GitHub Copilot subscription."
+        );
+      }
+      throw new Error(`Copilot API error: ${response.status} - ${errorText}`);
     }
-    const data = await response.json();
-    if (data.error) {
-      throw new Error(`Claude API error: ${data.error.message}`);
+    return this.parseStreamingResponse(response);
+  }
+  async parseStreamingResponse(response) {
+    if (!response.body) {
+      throw new Error("No response body from Copilot");
     }
-    const textContent = data.content.find((c) => c.type === "text");
-    if (!textContent) {
-      throw new Error("No text response from Claude");
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder("utf-8");
+    let buffer = "";
+    let fullText = "";
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() || "";
+        for (const line of lines) {
+          if (!line.trim() || !line.startsWith("data:")) continue;
+          const data = line.substring(5).trim();
+          if (data === "[DONE]") {
+            return fullText.trim();
+          }
+          try {
+            const chunk = JSON.parse(data);
+            const content = chunk.choices?.[0]?.delta?.content;
+            if (content) {
+              fullText += content;
+            }
+          } catch {
+          }
+        }
+      }
+    } finally {
+      reader.releaseLock();
     }
-    return textContent.text.trim();
+    if (!fullText) {
+      throw new Error("No response content from Copilot");
+    }
+    return fullText.trim();
   }
   async generateCommand(query, context) {
     const userMessage = context ? `Context: ${context}
@@ -660,29 +1642,20 @@ Task: ${query}` : query;
   }
   async validateCredentials() {
     try {
-      const response = await fetch("https://api.anthropic.com/v1/messages", {
-        method: "POST",
-        headers: {
-          "Content-Type": "application/json",
-          "x-api-key": this.apiKey,
-          "anthropic-version": "2023-06-01"
-        },
-        body: JSON.stringify({
-          model: this.model,
-          max_tokens: 10,
-          messages: [{ role: "user", content: "hi" }]
-        })
-      });
-      return response.ok;
+      const token = await this.ensureValidToken();
+      return !!token && token.length > 0;
     } catch {
       return false;
     }
   }
 };
-var CLAUDE_MODELS = [
-  { value: "claude-sonnet-4-20250514", label: "Claude Sonnet 4 (recommended)" },
-  { value: "claude-3-5-sonnet-20241022", label: "Claude 3.5 Sonnet" },
-  { value: "claude-3-5-haiku-20241022", label: "Claude 3.5 Haiku (fast)" }
+var COPILOT_MODELS = [
+  { value: "gpt-4.1", label: "GPT-4.1 (default)" },
+  { value: "gpt-5.1", label: "GPT-5.1 (latest)" },
+  { value: "gpt-5-mini", label: "GPT-5 Mini (fast)" },
+  { value: "claude-sonnet-4", label: "Claude Sonnet 4" },
+  { value: "claude-sonnet-4.5", label: "Claude Sonnet 4.5 (latest)" },
+  { value: "gpt-4o", label: "GPT-4o" }
 ];
 
 // src/providers/ollama.ts
@@ -823,9 +1796,12 @@ Task: ${query}` : query;
   }
 };
 var OPENAI_MODELS = [
-  { value: "gpt-4o", label: "GPT-4o (recommended)" },
-  { value: "gpt-4o-mini", label: "GPT-4o Mini (fast)" },
-  { value: "gpt-4-turbo", label: "GPT-4 Turbo" }
+  { value: "gpt-5.2", label: "GPT-5.2 (most intelligent)" },
+  { value: "gpt-5.1", label: "GPT-5.1 (recommended)" },
+  { value: "gpt-5-mini", label: "GPT-5 Mini (fast)" },
+  { value: "gpt-5-nano", label: "GPT-5 Nano (fastest)" },
+  { value: "gpt-4.1", label: "GPT-4.1" },
+  { value: "gpt-4o", label: "GPT-4o (legacy)" }
 ];
 
 // src/providers/openrouter.ts
@@ -909,21 +1885,35 @@ var OPENROUTER_MODELS = [
 
 // src/providers/index.ts
 function createProvider(config) {
+  const activeProvider = config.activeProvider;
+  const settings = config.providers[activeProvider];
+  if (!settings) {
+    throw new Error(`Provider ${activeProvider} not configured`);
+  }
   const providerConfig = {
-    model: config.model,
-    credentials: config.credentials
+    model: settings.model,
+    credentials: settings.credentials
   };
-  switch (config.provider) {
+  return createProviderFromType(activeProvider, providerConfig);
+}
+function createProviderFromType(provider, config) {
+  switch (provider) {
     case "claude":
-      return new ClaudeProvider(providerConfig);
+      return new ClaudeProvider(config);
+    case "claude-subscription":
+      return new ClaudeSubscriptionProvider(config);
     case "openai":
-      return new OpenAIProvider(providerConfig);
+      return new OpenAIProvider(config);
+    case "chatgpt-subscription":
+      return new ChatGPTSubscriptionProvider(config);
+    case "copilot":
+      return new CopilotProvider(config);
     case "ollama":
-      return new OllamaProvider(providerConfig);
+      return new OllamaProvider(config);
     case "openrouter":
-      return new OpenRouterProvider(providerConfig);
+      return new OpenRouterProvider(config);
     default:
-      throw new Error(`Unknown provider: ${config.provider}`);
+      throw new Error(`Unknown provider: ${provider}`);
   }
 }
 
@@ -937,6 +1927,28 @@ function createSpinner(text) {
 }
 
 // src/core/auth.ts
+var PROVIDER_DISPLAY_NAMES = {
+  "claude-subscription": "Claude Pro/Max",
+  "chatgpt-subscription": "ChatGPT Plus/Pro",
+  copilot: "GitHub Copilot",
+  claude: "Claude (API Key)",
+  openai: "ChatGPT (API Key)",
+  ollama: "Ollama (Local)",
+  openrouter: "OpenRouter"
+};
+async function openBrowser(url) {
+  try {
+    const { exec: exec2 } = await import("child_process");
+    const { promisify: promisify2 } = await import("util");
+    const execAsync2 = promisify2(exec2);
+    const platform = process.platform;
+    const command = platform === "darwin" ? `open "${url}"` : platform === "win32" ? `start "" "${url}"` : `xdg-open "${url}"`;
+    await execAsync2(command);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function showWelcomeBanner() {
   const cyan = pc3.cyan;
   const dim = pc3.dim;
@@ -997,17 +2009,33 @@ async function runAuthSetup(showBanner = true) {
     showWelcomeBanner();
   }
   console.log(pc3.bold("  Bashio Setup\n"));
+  const existingConfig = loadConfig();
   const provider = await select({
     message: "Select your AI provider:",
     choices: [
+      {
+        value: "claude-subscription",
+        name: "Claude Pro/Max (Subscription)",
+        description: "Use your existing Claude subscription"
+      },
+      {
+        value: "chatgpt-subscription",
+        name: "ChatGPT Plus/Pro (Subscription)",
+        description: "Use your existing ChatGPT subscription"
+      },
+      {
+        value: "copilot",
+        name: "GitHub Copilot",
+        description: "Use your GitHub Copilot subscription"
+      },
       {
         value: "claude",
-        name: "Claude (Anthropic)",
+        name: "Claude (API Key)",
         description: "Use Anthropic API key"
       },
       {
         value: "openai",
-        name: "ChatGPT (OpenAI)",
+        name: "ChatGPT (API Key)",
         description: "Use OpenAI API key"
       },
       {
@@ -1022,9 +2050,128 @@ async function runAuthSetup(showBanner = true) {
       }
     ]
   });
+  if (existingConfig && isProviderConfigured(existingConfig, provider)) {
+    const currentModel = existingConfig.providers[provider]?.model;
+    console.log();
+    console.log(
+      pc3.yellow(`  ${PROVIDER_DISPLAY_NAMES[provider]} is already configured.`)
+    );
+    console.log(pc3.dim(`  Current model: ${currentModel}`));
+    console.log();
+    const action = await select({
+      message: "What would you like to do?",
+      choices: [
+        { value: "reauth", name: "Update credentials (re-authenticate)" },
+        { value: "cancel", name: "Cancel" }
+      ]
+    });
+    if (action === "cancel") {
+      console.log(pc3.dim("\n  Cancelled.\n"));
+      return false;
+    }
+  }
   let credentials;
   let model;
   switch (provider) {
+    case "claude-subscription": {
+      console.log();
+      console.log(
+        pc3.yellow(
+          "  Note: This uses your Claude Pro/Max subscription via OAuth."
+        )
+      );
+      console.log(
+        pc3.dim(
+          "  Your credentials are stored locally and refreshed automatically."
+        )
+      );
+      console.log();
+      const tokens = await performClaudeOAuth();
+      if (!tokens) {
+        return false;
+      }
+      credentials = {
+        type: "claude_subscription",
+        accessToken: tokens.accessToken,
+        refreshToken: tokens.refreshToken,
+        expiresAt: tokens.expiresAt,
+        email: tokens.email
+      };
+      model = await select({
+        message: "Select model:",
+        choices: CLAUDE_SUBSCRIPTION_MODELS.map((m) => ({
+          value: m.value,
+          name: m.label
+        }))
+      });
+      break;
+    }
+    case "chatgpt-subscription": {
+      console.log();
+      console.log(
+        pc3.yellow(
+          "  Note: This uses your ChatGPT Plus/Pro subscription via OAuth."
+        )
+      );
+      console.log(
+        pc3.red("  WARNING: This is EXPERIMENTAL and uses an unofficial API.")
+      );
+      console.log(
+        pc3.dim("  The API may change or stop working without notice.")
+      );
+      console.log(
+        pc3.dim("  For stable usage, consider using an API key instead.")
+      );
+      console.log();
+      const tokens = await performChatGPTOAuth();
+      if (!tokens) {
+        return false;
+      }
+      credentials = {
+        type: "chatgpt_subscription",
+        accessToken: tokens.accessToken,
+        refreshToken: tokens.refreshToken || void 0,
+        expiresAt: tokens.expiresAt || void 0,
+        accountId: tokens.accountId
+      };
+      model = await select({
+        message: "Select model:",
+        choices: CHATGPT_SUBSCRIPTION_MODELS.map((m) => ({
+          value: m.value,
+          name: m.label
+        }))
+      });
+      break;
+    }
+    case "copilot": {
+      console.log();
+      console.log(
+        pc3.yellow("  Note: This uses your GitHub Copilot subscription.")
+      );
+      console.log(
+        pc3.dim("  You need an active GitHub Copilot subscription to use this.")
+      );
+      console.log();
+      const copilotResult = await performCopilotDeviceFlow();
+      if (!copilotResult) {
+        return false;
+      }
+      credentials = {
+        type: "copilot",
+        githubToken: copilotResult.githubToken,
+        copilotToken: copilotResult.copilotToken,
+        copilotTokenExpiresAt: copilotResult.copilotTokenExpiresAt,
+        apiEndpoint: copilotResult.apiEndpoint
+      };
+      model = await select({
+        message: "Select model:",
+        choices: COPILOT_MODELS.map((m) => ({
+          value: m.value,
+          name: m.label
+        }))
+      });
+      break;
+    }
     case "claude": {
       const apiKey = await password({
         message: "Enter your Anthropic API key:",
@@ -1098,12 +2245,12 @@ async function runAuthSetup(showBanner = true) {
     default:
       throw new Error(`Unknown provider: ${provider}`);
   }
-  const config = {
-    version: 1,
-    provider,
-    model,
-    credentials,
-    settings: {
+  const providerSettings = { model, credentials };
+  const tempConfig = {
+    version: 2,
+    activeProvider: provider,
+    providers: { [provider]: providerSettings },
+    settings: existingConfig?.settings || {
       confirmBeforeExecute: true,
       historyEnabled: true,
       historyRetentionDays: 30,
@@ -1113,7 +2260,7 @@ async function runAuthSetup(showBanner = true) {
   };
   const spinner = createSpinner("Validating credentials...").start();
   try {
-    const providerInstance = createProvider(config);
+    const providerInstance = createProvider(tempConfig);
     const valid = await providerInstance.validateCredentials();
     if (!valid) {
       spinner.fail("Invalid credentials");
@@ -1126,14 +2273,223 @@ async function runAuthSetup(showBanner = true) {
     );
     return false;
   }
-  saveConfig(config);
+  const finalConfig = existingConfig ? setProviderConfig(existingConfig, provider, providerSettings, true) : tempConfig;
+  saveConfig(finalConfig);
   console.log();
   logger.success("Configuration saved!");
-  console.log(pc3.gray(`  Provider: ${provider}`));
+  console.log(pc3.gray(`  Provider: ${PROVIDER_DISPLAY_NAMES[provider]}`));
   console.log(pc3.gray(`  Model: ${model}`));
   console.log();
   return true;
 }
+async function performClaudeOAuth() {
+  const authMethod = await select({
+    message: "How would you like to authenticate?",
+    choices: [
+      {
+        value: "browser",
+        name: "Open browser automatically",
+        description: "Recommended - opens browser and waits for callback"
+      },
+      {
+        value: "manual",
+        name: "Manual URL copy/paste",
+        description: "Copy URL to browser, then paste the callback URL"
+      }
+    ]
+  });
+  const pkce = generatePKCE();
+  const authUrl = buildClaudeAuthUrl(pkce);
+  if (authMethod === "browser") {
+    return performBrowserOAuth(
+      "Claude",
+      authUrl,
+      pkce,
+      CLAUDE_OAUTH_CONFIG.callbackPort,
+      async (code) => exchangeClaudeCode(code, pkce.codeVerifier, pkce.state)
+    );
+  }
+  return performManualOAuth(
+    "Claude",
+    authUrl,
+    pkce,
+    async (code) => exchangeClaudeCode(code, pkce.codeVerifier, pkce.state)
+  );
+}
+async function performChatGPTOAuth() {
+  const authMethod = await select({
+    message: "How would you like to authenticate?",
+    choices: [
+      {
+        value: "browser",
+        name: "Open browser automatically",
+        description: "Recommended - opens browser and waits for callback"
+      },
+      {
+        value: "manual",
+        name: "Manual URL copy/paste",
+        description: "Copy URL to browser, then paste the callback URL"
+      }
+    ]
+  });
+  const pkce = generatePKCE();
+  const authUrl = buildChatGPTAuthUrl(pkce);
+  if (authMethod === "browser") {
+    return performBrowserOAuth(
+      "ChatGPT",
+      authUrl,
+      pkce,
+      CHATGPT_OAUTH_CONFIG.callbackPort,
+      async (code) => exchangeChatGPTCode(code, pkce.codeVerifier)
+    );
+  }
+  return performManualOAuth(
+    "ChatGPT",
+    authUrl,
+    pkce,
+    async (code) => exchangeChatGPTCode(code, pkce.codeVerifier)
+  );
+}
+async function performBrowserOAuth(providerName, authUrl, pkce, port, exchangeCode) {
+  console.log();
+  console.log(pc3.dim("  Starting local callback server..."));
+  const serverPromise = startCallbackServer(port, pkce.state);
+  const browserOpened = await openBrowser(authUrl);
+  if (browserOpened) {
+    console.log(
+      pc3.green(`  Browser opened. Please log in to ${providerName}.`)
+    );
+  } else {
+    console.log(pc3.yellow("  Could not open browser automatically."));
+    console.log(pc3.dim("  Please open this URL manually:"));
+    console.log();
+    console.log(`  ${pc3.cyan(authUrl)}`);
+  }
+  console.log();
+  console.log(pc3.dim("  Waiting for authentication (5 minute timeout)..."));
+  try {
+    const { code } = await serverPromise;
+    const spinner = createSpinner("Exchanging authorization code...").start();
+    try {
+      const tokens = await exchangeCode(code);
+      spinner.succeed("Authentication successful!");
+      return tokens;
+    } catch (error) {
+      spinner.fail(
+        `Token exchange failed: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      return null;
+    }
+  } catch (error) {
+    logger.error(
+      `Authentication failed: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+    return null;
+  }
+}
+async function performManualOAuth(providerName, authUrl, pkce, exchangeCode) {
+  console.log();
+  console.log(
+    pc3.dim(
+      `  Open this URL in your browser to authenticate with ${providerName}:`
+    )
+  );
+  console.log();
+  console.log(`  ${pc3.cyan(authUrl)}`);
+  console.log();
+  console.log(
+    pc3.dim("  After logging in, you will be redirected to a localhost URL.")
+  );
+  console.log(pc3.dim("  Copy the full redirect URL and paste it below."));
+  console.log();
+  const callbackUrl = await input3({
+    message: "Paste the callback URL here:"
+  });
+  try {
+    const url = new URL(callbackUrl);
+    const code = url.searchParams.get("code");
+    const state = url.searchParams.get("state");
+    const error = url.searchParams.get("error");
+    if (error) {
+      logger.error(`OAuth error: ${error}`);
+      return null;
+    }
+    if (!code) {
+      logger.error("No authorization code found in URL");
+      return null;
+    }
+    if (state !== pkce.state) {
+      logger.error("State mismatch - possible security issue");
+      return null;
+    }
+    const spinner = createSpinner("Exchanging authorization code...").start();
+    try {
+      const tokens = await exchangeCode(code);
+      spinner.succeed("Authentication successful!");
+      return tokens;
+    } catch (err) {
+      spinner.fail(
+        `Token exchange failed: ${err instanceof Error ? err.message : "Unknown error"}`
+      );
+      return null;
+    }
+  } catch {
+    logger.error("Invalid URL format");
+    return null;
+  }
+}
+async function performCopilotDeviceFlow() {
+  try {
+    const spinner = createSpinner("Requesting device code...").start();
+    const deviceCode = await requestCopilotDeviceCode();
+    spinner.stop();
+    console.log();
+    console.log(pc3.bold("  To authenticate with GitHub Copilot:"));
+    console.log();
+    console.log(
+      `  1. Visit: ${pc3.cyan(pc3.underline(deviceCode.verification_uri))}`
+    );
+    console.log(`  2. Enter code: ${pc3.bold(pc3.green(deviceCode.user_code))}`);
+    console.log();
+    const browserOpened = await openBrowser(deviceCode.verification_uri);
+    if (browserOpened) {
+      console.log(pc3.dim("  Browser opened automatically."));
+    }
+    console.log(pc3.dim("  Waiting for authorization..."));
+    console.log();
+    const expiresAt = Date.now() + deviceCode.expires_in * 1e3;
+    const intervalMs = (deviceCode.interval || 5) * 1e3;
+    const githubToken = await pollForCopilotAccessToken(
+      deviceCode.device_code,
+      intervalMs,
+      expiresAt
+    );
+    const exchangeSpinner = createSpinner(
+      "Getting Copilot access token..."
+    ).start();
+    try {
+      const copilotTokenData = await exchangeGitHubTokenForCopilot(githubToken);
+      const parsed = parseCopilotToken(copilotTokenData.token);
+      exchangeSpinner.succeed("Authentication successful!");
+      return {
+        githubToken,
+        copilotToken: copilotTokenData.token,
+        copilotTokenExpiresAt: parsed.expiresAt,
+        apiEndpoint: parsed.apiEndpoint
+      };
+    } catch (error) {
+      exchangeSpinner.fail(
+        `Failed to get Copilot token: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+      return null;
+    }
+  } catch (error) {
+    logger.error(
+      `GitHub authentication failed: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+    return null;
+  }
+}
 
 // src/cli/commands/AuthCommand.ts
 var AuthCommand = class extends Command2 {
@@ -1280,15 +2636,32 @@ var ConfigCommand = class extends Command4 {
       logger.error("Failed to load configuration.");
       return 1;
     }
+    const activeSettings = config.providers[config.activeProvider];
+    const configuredProviders = Object.keys(config.providers);
     console.log(pc7.bold("\n  Bashio Configuration\n"));
-    console.log(`  Provider:    ${pc7.cyan(config.provider)}`);
-    console.log(`  Model:       ${pc7.cyan(config.model)}`);
-    console.log(`  Auth:        ${pc7.green("Configured")}`);
+    console.log(
+      `  Active Provider: ${pc7.cyan(PROVIDER_DISPLAY_NAMES[config.activeProvider])}`
+    );
+    console.log(
+      `  Model:           ${pc7.cyan(activeSettings?.model || "N/A")}`
+    );
+    if (configuredProviders.length > 1) {
+      console.log();
+      console.log(pc7.bold("  Configured Providers"));
+      for (const p of configuredProviders) {
+        const settings2 = config.providers[p];
+        const isActive = p === config.activeProvider;
+        const marker = isActive ? pc7.green("\u25CF") : pc7.dim("\u25CB");
+        console.log(
+          `  ${marker} ${PROVIDER_DISPLAY_NAMES[p]} - ${pc7.dim(settings2?.model || "N/A")}`
+        );
+      }
+    }
     const settings = config.settings;
     console.log();
     console.log(pc7.bold("  Settings"));
     console.log(
-      `  History:              ${settings?.historyEnabled !== false ? pc7.green("enabled") : pc7.gray("disabled")}`
+      `  History:                ${settings?.historyEnabled !== false ? pc7.green("enabled") : pc7.gray("disabled")}`
     );
     console.log(
       `  Auto-confirm shortcuts: ${settings?.autoConfirmShortcuts ? pc7.green("enabled") : pc7.gray("disabled")}`
@@ -2029,16 +3402,35 @@ var selectWithEsc = async (config) => {
   }
 };
 var isPromptExit = (error) => {
-  if (!(error instanceof Error)) {
-    return false;
-  }
-  return error.name === "ExitPromptError" || error.name === "AbortPromptError" || error.name === "CancelPromptError";
+  if (!(error instanceof Error)) return false;
+  return error.name === "ExitPromptError" || error.name === "AbortPromptError" || error.name === "CancelPromptError" || error.message.includes("SIGINT") || error.message.includes("force closed");
 };
+function getModelsForProvider(provider) {
+  switch (provider) {
+    case "claude":
+      return CLAUDE_MODELS;
+    case "claude-subscription":
+      return CLAUDE_SUBSCRIPTION_MODELS;
+    case "openai":
+      return OPENAI_MODELS;
+    case "chatgpt-subscription":
+      return CHATGPT_SUBSCRIPTION_MODELS;
+    case "copilot":
+      return COPILOT_MODELS;
+    case "openrouter":
+      return OPENROUTER_MODELS;
+    case "ollama":
+      return [];
+    // Handled separately
+    default:
+      return [];
+  }
+}
 var ModelCommand = class extends Command8 {
   static paths = [["model"], ["--model"]];
   static usage = Command8.Usage({
-    description: "Change the AI model for current provider",
-    examples: [["Change model", "$0 --model"]]
+    description: "Change the AI provider and model",
+    examples: [["Change provider/model", "$0 --model"]]
   });
   async execute() {
     if (!configExists()) {
@@ -2053,70 +3445,95 @@ var ModelCommand = class extends Command8 {
       logger.error("Failed to load configuration.");
       return 1;
     }
-    console.log(pc12.bold("\n  Change AI Model\n"));
-    console.log(pc12.gray(`  Current provider: ${config.provider}`));
-    console.log(pc12.gray(`  Current model: ${config.model}`));
+    const configuredProviders = Object.keys(config.providers);
+    if (configuredProviders.length === 0) {
+      logger.warn("No providers configured.");
+      console.log(pc12.gray("Run 'b --auth' to set up a provider.\n"));
+      return 1;
+    }
+    const activeSettings = config.providers[config.activeProvider];
+    console.log(pc12.bold("\n  Change Provider & Model\n"));
+    console.log(
+      pc12.gray(
+        `  Current: ${PROVIDER_DISPLAY_NAMES[config.activeProvider]} / ${activeSettings?.model}`
+      )
+    );
     console.log(pc12.dim("  Press Esc to cancel\n"));
-    let newModel;
     try {
-      switch (config.provider) {
-        case "claude": {
-          newModel = await selectWithEsc({
-            message: "Select new model:",
-            choices: CLAUDE_MODELS.map((m) => ({
-              value: m.value,
-              name: m.label
-            })),
-            default: config.model
-          });
-          break;
-        }
-        case "openai": {
-          newModel = await selectWithEsc({
-            message: "Select new model:",
-            choices: OPENAI_MODELS.map((m) => ({
-              value: m.value,
-              name: m.label
-            })),
-            default: config.model
-          });
-          break;
+      const providerChoices = configuredProviders.map((p) => {
+        const settings = config.providers[p];
+        const isActive = p === config.activeProvider;
+        const marker = isActive ? pc12.green("\u25CF") : pc12.dim("\u25CB");
+        const name = `${marker} ${PROVIDER_DISPLAY_NAMES[p]}`;
+        const description = settings?.model || "Not configured";
+        return { value: p, name, description };
+      });
+      providerChoices.push({
+        value: "__add_new__",
+        name: pc12.cyan("+ Add new provider..."),
+        description: "Configure a new AI provider"
+      });
+      const selectedProvider = await selectWithEsc({
+        message: "Select provider:",
+        choices: providerChoices
+      });
+      if (selectedProvider === "__add_new__") {
+        console.log(pc12.dim("\n  Run 'b --auth' to add a new provider.\n"));
+        return 0;
+      }
+      const currentModel = config.providers[selectedProvider]?.model;
+      let newModel;
+      if (selectedProvider === "ollama") {
+        const host = config.providers.ollama?.credentials.type === "local" ? config.providers.ollama.credentials.host : "http://localhost:11434";
+        const spinner = createSpinner("Fetching available models...").start();
+        const availableModels = await OllamaProvider.getAvailableModels(host);
+        spinner.stop();
+        if (availableModels.length === 0) {
+          logger.warn("No models found. Make sure Ollama is running.");
+          console.log(pc12.gray("\n  Install a model: ollama pull llama3.2\n"));
+          return 1;
         }
-        case "ollama": {
-          const host = config.credentials.type === "local" ? config.credentials.host : "http://localhost:11434";
-          const spinner = createSpinner("Fetching available models...").start();
-          const availableModels = await OllamaProvider.getAvailableModels(host);
-          spinner.stop();
-          if (availableModels.length === 0) {
-            logger.warn("No models found. Make sure Ollama is running.");
-            console.log(pc12.gray("\n  Install a model: ollama pull llama3.2\n"));
-            return 1;
+        newModel = await selectWithEsc({
+          message: "Select model:",
+          choices: availableModels.map((m) => ({ value: m, name: m })),
+          default: currentModel
+        });
+      } else {
+        const models = getModelsForProvider(selectedProvider);
+        newModel = await selectWithEsc({
+          message: "Select model:",
+          choices: models.map((m) => ({ value: m.value, name: m.label })),
+          default: currentModel
+        });
+      }
+      const providerSettings = config.providers[selectedProvider];
+      if (!providerSettings) {
+        logger.error("Provider not configured.");
+        return 1;
+      }
+      const updatedConfig = {
+        ...config,
+        activeProvider: selectedProvider,
+        providers: {
+          ...config.providers,
+          [selectedProvider]: {
+            ...providerSettings,
+            model: newModel
           }
-          newModel = await selectWithEsc({
-            message: "Select new model:",
-            choices: availableModels.map((m) => ({
-              value: m,
-              name: m
-            })),
-            default: config.model
-          });
-          break;
-        }
-        case "openrouter": {
-          newModel = await selectWithEsc({
-            message: "Select new model:",
-            choices: OPENROUTER_MODELS.map((m) => ({
-              value: m.value,
-              name: m.label
-            })),
-            default: config.model
-          });
-          break;
         }
-        default:
-          logger.error(`Unknown provider: ${config.provider}`);
-          return 1;
+      };
+      saveConfig(updatedConfig);
+      const changed = selectedProvider !== config.activeProvider || newModel !== currentModel;
+      if (changed) {
+        console.log();
+        logger.success(
+          `Switched to: ${PROVIDER_DISPLAY_NAMES[selectedProvider]} / ${newModel}`
+        );
+      } else {
+        logger.info("No changes made.");
       }
+      console.log();
+      return 0;
     } catch (error) {
       if (isPromptExit(error)) {
         console.log(pc12.dim("\n  Cancelled.\n"));
@@ -2124,16 +3541,6 @@ var ModelCommand = class extends Command8 {
       }
       throw error;
     }
-    if (newModel === config.model) {
-      logger.info("Model unchanged.");
-      return 0;
-    }
-    config.model = newModel;
-    saveConfig(config);
-    console.log();
-    logger.success(`Model changed to: ${newModel}`);
-    console.log();
-    return 0;
   }
 };
 
@@ -2546,7 +3953,7 @@ var SuggestShortcutsCommand = class extends Command12 {
 // src/cli/index.ts
 var pkg = {
   name: "bashio",
-  version: "0.7.0"
+  version: "1.1.1"
 };
 var notifier = updateNotifier({
   pkg,