bashio 1.0.0 → 1.1.0

package/dist/index.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
+import { createRequire } from "module";
 import { Builtins, Cli } from "clipanion";
 import pc17 from "picocolors";
 import updateNotifier from "update-notifier";
@@ -20,7 +21,10 @@ import { join } from "path";
 import { z } from "zod";
 var ProviderName = z.enum([
   "claude",
+  "claude-subscription",
   "openai",
+  "chatgpt-subscription",
+  "copilot",
   "ollama",
   "openrouter"
 ]);
@@ -36,10 +40,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),
@@ -587,6 +622,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 +1023,181 @@ 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();
+        if (currentConfig && currentConfig.credentials.type === "chatgpt_subscription") {
+          currentConfig.credentials.accessToken = newTokens.accessToken;
+          if (newTokens.refreshToken) {
+            currentConfig.credentials.refreshToken = newTokens.refreshToken;
+          }
+          if (newTokens.expiresAt) {
+            currentConfig.credentials.expiresAt = newTokens.expiresAt;
+          }
+          if (this.accountId) {
+            currentConfig.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";
@@ -680,9 +1276,337 @@ Task: ${query}` : query;
   }
 };
 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)" }
+  {
+    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();
+        if (currentConfig && currentConfig.credentials.type === "claude_subscription") {
+          currentConfig.credentials.accessToken = newTokens.accessToken;
+          currentConfig.credentials.refreshToken = newTokens.refreshToken;
+          currentConfig.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();
+        if (currentConfig && currentConfig.credentials.type === "copilot") {
+          currentConfig.credentials.copilotToken = newTokenData.token;
+          currentConfig.credentials.copilotTokenExpiresAt = parsed.expiresAt;
+          currentConfig.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}`);
+    }
+    return this.parseStreamingResponse(response);
+  }
+  async parseStreamingResponse(response) {
+    if (!response.body) {
+      throw new Error("No response body from Copilot");
+    }
+    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();
+    }
+    if (!fullText) {
+      throw new Error("No response content from Copilot");
+    }
+    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 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 +1747,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
@@ -916,8 +1843,14 @@ function createProvider(config) {
   switch (config.provider) {
     case "claude":
       return new ClaudeProvider(providerConfig);
+    case "claude-subscription":
+      return new ClaudeSubscriptionProvider(providerConfig);
     case "openai":
       return new OpenAIProvider(providerConfig);
+    case "chatgpt-subscription":
+      return new ChatGPTSubscriptionProvider(providerConfig);
+    case "copilot":
+      return new CopilotProvider(providerConfig);
     case "ollama":
       return new OllamaProvider(providerConfig);
     case "openrouter":
@@ -937,6 +1870,19 @@ function createSpinner(text) {
 }
 
 // src/core/auth.ts
+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;
@@ -1000,14 +1946,29 @@ async function runAuthSetup(showBanner = true) {
   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"
       },
       {
@@ -1025,6 +1986,105 @@ async function runAuthSetup(showBanner = true) {
   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:",
@@ -1134,6 +2194,214 @@ async function runAuthSetup(showBanner = true) {
   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 {
@@ -2113,6 +3381,39 @@ var ModelCommand = class extends Command8 {
           });
           break;
         }
+        case "claude-subscription": {
+          newModel = await selectWithEsc({
+            message: "Select new model:",
+            choices: CLAUDE_SUBSCRIPTION_MODELS.map((m) => ({
+              value: m.value,
+              name: m.label
+            })),
+            default: config.model
+          });
+          break;
+        }
+        case "chatgpt-subscription": {
+          newModel = await selectWithEsc({
+            message: "Select new model:",
+            choices: CHATGPT_SUBSCRIPTION_MODELS.map((m) => ({
+              value: m.value,
+              name: m.label
+            })),
+            default: config.model
+          });
+          break;
+        }
+        case "copilot": {
+          newModel = await selectWithEsc({
+            message: "Select new model:",
+            choices: COPILOT_MODELS.map((m) => ({
+              value: m.value,
+              name: m.label
+            })),
+            default: config.model
+          });
+          break;
+        }
         default:
           logger.error(`Unknown provider: ${config.provider}`);
           return 1;
@@ -2544,9 +3845,11 @@ var SuggestShortcutsCommand = class extends Command12 {
 };
 
 // src/cli/index.ts
+var require2 = createRequire(import.meta.url);
+var packageJson = require2("../../package.json");
 var pkg = {
-  name: "bashio",
-  version: "0.7.0"
+  name: packageJson.name,
+  version: packageJson.version
 };
 var notifier = updateNotifier({
   pkg,