@oevortex/opencode-qwen-auth 0.1.0 → 0.1.1

package/src/plugin/fetch-wrapper.ts

@@ -1,460 +0,0 @@
-/**
- * Fetch wrapper for Qwen API requests
- * Handles authentication, token refresh, rate limiting, and request transformation
- */
-
-import {
-  QWEN_DEFAULT_BASE_URL,
-  QWEN_PORTAL_BASE_URL,
-  QWEN_PROVIDER_ID,
-  RATE_LIMIT_BACKOFF_BASE_MS,
-  RATE_LIMIT_BACKOFF_MAX_MS,
-  RATE_LIMIT_MAX_RETRIES,
-  HTTP_UNAUTHORIZED,
-} from "../constants";
-
-import type {
-  OAuthAuthDetails,
-  PluginContext,
-  GetAuth,
-  RateLimitState,
-  RateLimitDelay,
-} from "../types";
-
-import { isOAuthAuth, accessTokenExpired, parseRefreshParts } from "./auth";
-import { refreshAccessToken } from "./token";
-import { createLogger, printQwenConsole } from "./logger";
-
-const log = createLogger("fetch-wrapper");
-
-/**
- * Rate limit state tracking per session.
- */
-const rateLimitState: RateLimitState = {
-  consecutive429: 0,
-  lastAt: 0,
-};
-
-/**
- * Compute exponential backoff delay for rate limiting.
- */
-export function computeExponentialBackoffMs(
-  attempt: number,
-  baseMs: number = RATE_LIMIT_BACKOFF_BASE_MS,
-  maxMs: number = RATE_LIMIT_BACKOFF_MAX_MS
-): number {
-  const safeAttempt = Math.max(1, Math.floor(attempt));
-  const multiplier = 2 ** (safeAttempt - 1);
-  return Math.min(maxMs, Math.max(0, Math.floor(baseMs * multiplier)));
-}
-
-/**
- * Convert URL or Request to string URL.
- */
-function toUrlString(value: RequestInfo | URL): string {
-  if (value instanceof URL) {
-    return value.toString();
-  }
-  if (typeof value === "string") {
-    return value;
-  }
-  return (value as Request).url ?? value.toString();
-}
-
-/**
- * Sleep for a specified duration with abort signal support.
- */
-export function sleep(ms: number, signal?: AbortSignal | null): Promise<void> {
-  return new Promise((resolve, reject) => {
-    if (signal?.aborted) {
-      reject(signal.reason instanceof Error ? signal.reason : new Error("Aborted"));
-      return;
-    }
-
-    const timeout = setTimeout(() => {
-      cleanup();
-      resolve();
-    }, ms);
-
-    const onAbort = () => {
-      cleanup();
-      reject(signal?.reason instanceof Error ? signal.reason : new Error("Aborted"));
-    };
-
-    const cleanup = () => {
-      clearTimeout(timeout);
-      signal?.removeEventListener("abort", onAbort);
-    };
-
-    signal?.addEventListener("abort", onAbort, { once: true });
-  });
-}
-
-/**
- * Sleep with progressive backoff for long waits.
- */
-export async function sleepWithBackoff(
-  totalMs: number,
-  signal?: AbortSignal | null
-): Promise<void> {
-  const stepsMs = [3000, 5000, 10000, 20000, 30000];
-  let remainingMs = Math.max(0, totalMs);
-  let stepIndex = 0;
-
-  while (remainingMs > 0) {
-    const stepMs = stepsMs[stepIndex] ?? stepsMs[stepsMs.length - 1] ?? 30000;
-    const waitMs = Math.min(remainingMs, stepMs);
-    await sleep(waitMs, signal);
-    remainingMs -= waitMs;
-    stepIndex++;
-  }
-}
-
-/**
- * Format milliseconds as human-readable time string.
- */
-function formatWaitTimeMs(ms: number): string {
-  const totalSeconds = Math.max(1, Math.ceil(ms / 1000));
-  const hours = Math.floor(totalSeconds / 3600);
-  const minutes = Math.floor((totalSeconds % 3600) / 60);
-  const seconds = totalSeconds % 60;
-
-  if (hours > 0) {
-    return minutes > 0 ? `${hours}h${minutes}m` : `${hours}h`;
-  }
-  if (minutes > 0) {
-    return seconds > 0 ? `${minutes}m${seconds}s` : `${minutes}m`;
-  }
-  return `${seconds}s`;
-}
-
-/**
- * Check if a URL is a Qwen API request.
- */
-function isQwenApiRequest(input: RequestInfo | URL): boolean {
-  const urlString = toUrlString(input);
-  return (
-    urlString.includes("dashscope.aliyuncs.com") ||
-    urlString.includes("portal.qwen.ai") ||
-    urlString.includes("chat.qwen.ai") ||
-    urlString.includes("/v1/chat/completions") ||
-    urlString.includes("/compatible-mode/v1")
-  );
-}
-
-/**
- * Get the base URL for Qwen API requests.
- * Uses OAuth resource URL if available, otherwise default.
- */
-function getBaseUrl(auth: OAuthAuthDetails): string {
-  const parts = parseRefreshParts(auth.refresh);
-  let baseUrl = parts.resourceUrl || QWEN_PORTAL_BASE_URL;
-
-  if (!baseUrl.startsWith("http://") && !baseUrl.startsWith("https://")) {
-    baseUrl = `https://${baseUrl}`;
-  }
-
-  baseUrl = baseUrl.replace(/\/+$/, "");
-  if (!baseUrl.endsWith("/v1")) {
-    baseUrl = `${baseUrl}/v1`;
-  }
-
-  return baseUrl;
-}
-
-/**
- * Parse Retry-After header from response.
- */
-function parseRetryAfterMs(response: Response): number | null {
-  const retryAfterMsHeader = response.headers.get("retry-after-ms");
-  const retryAfterSecondsHeader = response.headers.get("retry-after");
-
-  if (retryAfterMsHeader) {
-    const parsed = parseInt(retryAfterMsHeader, 10);
-    if (!Number.isNaN(parsed) && parsed >= 0) {
-      return Math.min(parsed, RATE_LIMIT_BACKOFF_MAX_MS);
-    }
-  }
-
-  if (retryAfterSecondsHeader) {
-    const parsed = parseInt(retryAfterSecondsHeader, 10);
-    if (!Number.isNaN(parsed) && parsed >= 0) {
-      return Math.min(parsed * 1000, RATE_LIMIT_BACKOFF_MAX_MS);
-    }
-  }
-
-  return null;
-}
-
-/**
- * Get rate limit delay information.
- */
-function getRateLimitDelay(serverRetryAfterMs: number | null): RateLimitDelay {
-  const now = Date.now();
-  const attempt = rateLimitState.consecutive429 + 1;
-  const backoffMs = computeExponentialBackoffMs(attempt);
-  const delayMs = serverRetryAfterMs !== null ? Math.max(serverRetryAfterMs, backoffMs) : backoffMs;
-
-  rateLimitState.consecutive429 = attempt;
-  rateLimitState.lastAt = now;
-
-  return { attempt, serverRetryAfterMs, delayMs };
-}
-
-/**
- * Reset rate limit state after successful request.
- */
-function resetRateLimitState(): void {
-  rateLimitState.consecutive429 = 0;
-  rateLimitState.lastAt = 0;
-}
-
-/**
- * Prepare headers for Qwen API request.
- */
-function prepareHeaders(
-  init: RequestInit | undefined,
-  accessToken: string
-): Headers {
-  const headers = new Headers(init?.headers);
-
-  // Set authorization
-  headers.set("Authorization", `Bearer ${accessToken}`);
-
-  // Ensure content type is set
-  if (!headers.has("Content-Type")) {
-    headers.set("Content-Type", "application/json");
-  }
-
-  // Set accept header
-  if (!headers.has("Accept")) {
-    headers.set("Accept", "application/json");
-  }
-
-  return headers;
-}
-
-/**
- * Transform request URL to use correct Qwen base URL.
- */
-function transformRequestUrl(input: RequestInfo | URL, baseUrl: string): string {
-  const urlString = toUrlString(input);
-
-  // If it's already a full URL with a recognized host, replace the base
-  if (urlString.includes("generativelanguage.googleapis.com")) {
-    // This is a Google API URL, transform to Qwen
-    const path = urlString.split("/v1")[1] || "/chat/completions";
-    return `${baseUrl}${path}`;
-  }
-
-  // If it's a relative path, prepend base URL
-  if (urlString.startsWith("/")) {
-    return `${baseUrl}${urlString}`;
-  }
-
-  // If URL already points to Qwen, use as-is
-  if (isQwenApiRequest(urlString)) {
-    return urlString;
-  }
-
-  // Default: assume it's a chat completions request
-  if (!urlString.includes("/chat/completions")) {
-    return `${baseUrl}/chat/completions`;
-  }
-
-  return urlString;
-}
-
-/**
- * Create a fetch wrapper that handles Qwen API authentication.
- *
- * This wrapper:
- * - Automatically refreshes tokens when expired
- * - Handles rate limiting with exponential backoff
- * - Transforms requests for Qwen API compatibility
- * - Retries on auth failures
- */
-export function createQwenFetch(
-  getAuth: GetAuth,
-  client: PluginContext["client"]
-): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response> {
-  return async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-    // Get current auth
-    const auth = await getAuth();
-
-    // If not OAuth auth, pass through to normal fetch
-    if (!isOAuthAuth(auth)) {
-      return fetch(input, init);
-    }
-
-    // Check if this is a Qwen API request
-    const urlString = toUrlString(input);
-    if (!isQwenApiRequest(urlString) && !urlString.includes("googleapis.com")) {
-      return fetch(input, init);
-    }
-
-    // Ensure we have a valid access token
-    let currentAuth = auth;
-    if (accessTokenExpired(currentAuth)) {
-      log.debug("Access token expired, refreshing...");
-      const refreshed = await refreshAccessToken(currentAuth, client);
-      if (!refreshed) {
-        throw new Error("Failed to refresh access token");
-      }
-      currentAuth = refreshed;
-
-      // Save refreshed auth
-      try {
-        await client.auth.set({
-          path: { id: QWEN_PROVIDER_ID },
-          body: {
-            type: "oauth",
-            access: refreshed.access,
-            refresh: refreshed.refresh,
-            expires: refreshed.expires,
-          },
-        });
-      } catch (saveError) {
-        log.warn("Failed to save refreshed auth", {
-          error: saveError instanceof Error ? saveError.message : String(saveError),
-        });
-      }
-    }
-
-    const accessToken = currentAuth.access;
-    if (!accessToken) {
-      throw new Error("No access token available");
-    }
-
-    // Get base URL and prepare request
-    const baseUrl = getBaseUrl(currentAuth);
-    const requestUrl = transformRequestUrl(input, baseUrl);
-    const headers = prepareHeaders(init, accessToken);
-
-    const abortSignal = init?.signal;
-
-    // Retry loop for rate limiting
-    let retryCount = 0;
-    while (retryCount <= RATE_LIMIT_MAX_RETRIES) {
-      try {
-        log.debug("Making Qwen API request", {
-          url: requestUrl,
-          method: init?.method || "GET",
-          retry: retryCount,
-        });
-
-        const response = await fetch(requestUrl, {
-          ...init,
-          headers,
-        });
-
-        // Handle 401 Unauthorized - refresh token and retry once
-        if (response.status === HTTP_UNAUTHORIZED && retryCount === 0) {
-          log.info("Received 401, refreshing token and retrying...");
-
-          const refreshed = await refreshAccessToken(currentAuth, client);
-          if (!refreshed) {
-            return response; // Return 401 response if refresh fails
-          }
-
-          currentAuth = refreshed;
-          headers.set("Authorization", `Bearer ${refreshed.access}`);
-
-          // Save refreshed auth
-          try {
-            await client.auth.set({
-              path: { id: QWEN_PROVIDER_ID },
-              body: {
-                type: "oauth",
-                access: refreshed.access,
-                refresh: refreshed.refresh,
-                expires: refreshed.expires,
-              },
-            });
-          } catch {}
-
-          retryCount++;
-          continue;
-        }
-
-        // Handle 429 Rate Limit
-        if (response.status === 429) {
-          const serverRetryAfterMs = parseRetryAfterMs(response);
-          const { attempt, delayMs } = getRateLimitDelay(serverRetryAfterMs);
-
-          if (attempt > RATE_LIMIT_MAX_RETRIES) {
-            log.warn("Max rate limit retries exceeded", { attempt });
-            return response;
-          }
-
-          printQwenConsole(
-            "error",
-            `Rate limited (429). Retrying after ${formatWaitTimeMs(delayMs)} (attempt ${attempt})...`
-          );
-
-          await client.tui.showToast({
-            body: {
-              message: `Rate limited. Retrying in ${formatWaitTimeMs(delayMs)}...`,
-              variant: "warning",
-            },
-          });
-
-          await sleepWithBackoff(delayMs, abortSignal);
-          retryCount++;
-          continue;
-        }
-
-        // Handle 5xx server errors with retry
-        if (response.status >= 500 && retryCount < RATE_LIMIT_MAX_RETRIES) {
-          log.warn("Server error, retrying...", { status: response.status });
-          const delayMs = computeExponentialBackoffMs(retryCount + 1);
-          await sleep(delayMs, abortSignal);
-          retryCount++;
-          continue;
-        }
-
-        // Success - reset rate limit state
-        if (response.ok) {
-          resetRateLimitState();
-        }
-
-        return response;
-      } catch (error) {
-        // Network errors - retry with backoff
-        if (retryCount < RATE_LIMIT_MAX_RETRIES) {
-          const errorMessage = error instanceof Error ? error.message : String(error);
-          log.warn("Request failed, retrying...", { error: errorMessage, retry: retryCount });
-
-          const delayMs = computeExponentialBackoffMs(retryCount + 1);
-          await sleep(delayMs, abortSignal);
-          retryCount++;
-          continue;
-        }
-
-        throw error;
-      }
-    }
-
-    // Should not reach here, but just in case
-    throw new Error("Max retries exceeded");
-  };
-}
-
-/**
- * Create a simple fetch wrapper that just adds auth headers.
- * Use this for non-retrying scenarios.
- */
-export function createSimpleQwenFetch(
-  accessToken: string,
-  baseUrl: string = QWEN_DEFAULT_BASE_URL
-): (input: RequestInfo | URL, init?: RequestInit) => Promise<Response> {
-  return async (input: RequestInfo | URL, init?: RequestInit): Promise<Response> => {
-    const requestUrl = transformRequestUrl(input, baseUrl);
-    const headers = prepareHeaders(init, accessToken);
-
-    return fetch(requestUrl, {
-      ...init,
-      headers,
-    });
-  };
-}

package/src/plugin/logger.ts

@@ -1,111 +0,0 @@
-/**
- * Logger utility for the Qwen OpenCode plugin
- */
-
-import { ENV_CONSOLE_LOG } from "../constants";
-import type { PluginContext } from "../types";
-
-type LogLevel = "debug" | "info" | "warn" | "error";
-
-interface Logger {
-  debug: (message: string, meta?: Record<string, unknown>) => void;
-  info: (message: string, meta?: Record<string, unknown>) => void;
-  warn: (message: string, meta?: Record<string, unknown>) => void;
-  error: (message: string, meta?: Record<string, unknown>) => void;
-}
-
-let pluginClient: PluginContext["client"] | null = null;
-
-/**
- * Initialize the logger with the plugin client.
- * Should be called once when the plugin loads.
- */
-export function initLogger(client: PluginContext["client"]): void {
-  pluginClient = client;
-}
-
-/**
- * Check if console logging is enabled via environment variable.
- */
-function isConsoleLogEnabled(): boolean {
-  const value = process.env[ENV_CONSOLE_LOG];
-  return value === "1" || value === "true";
-}
-
-/**
- * Format a log message with optional metadata.
- */
-function formatMessage(prefix: string, message: string, meta?: Record<string, unknown>): string {
-  const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
-  return `[${prefix}] ${message}${metaStr}`;
-}
-
-/**
- * Print to console if console logging is enabled.
- */
-export function printQwenConsole(level: LogLevel, message: string, meta?: Record<string, unknown>): void {
-  if (!isConsoleLogEnabled()) {
-    return;
-  }
-
-  const formattedMessage = formatMessage("qwen-auth", message, meta);
-
-  switch (level) {
-    case "debug":
-      console.debug(formattedMessage);
-      break;
-    case "info":
-      console.info(formattedMessage);
-      break;
-    case "warn":
-      console.warn(formattedMessage);
-      break;
-    case "error":
-      console.error(formattedMessage);
-      break;
-  }
-}
-
-/**
- * Create a logger instance with a specific prefix.
- * Uses the plugin client's log methods if available, falls back to console.
- */
-export function createLogger(prefix: string): Logger {
-  const log = (level: LogLevel, message: string, meta?: Record<string, unknown>): void => {
-    // Always print to console if enabled
-    printQwenConsole(level, `[${prefix}] ${message}`, meta);
-
-    // Use plugin client logger if available
-    if (pluginClient?.log) {
-      const clientLog = pluginClient.log;
-      const formattedMessage = `[${prefix}] ${message}`;
-
-      switch (level) {
-        case "debug":
-          clientLog.debug(formattedMessage, meta);
-          break;
-        case "info":
-          clientLog.info(formattedMessage, meta);
-          break;
-        case "warn":
-          clientLog.warn(formattedMessage, meta);
-          break;
-        case "error":
-          clientLog.error(formattedMessage, meta);
-          break;
-      }
-    }
-  };
-
-  return {
-    debug: (message: string, meta?: Record<string, unknown>) => log("debug", message, meta),
-    info: (message: string, meta?: Record<string, unknown>) => log("info", message, meta),
-    warn: (message: string, meta?: Record<string, unknown>) => log("warn", message, meta),
-    error: (message: string, meta?: Record<string, unknown>) => log("error", message, meta),
-  };
-}
-
-/**
- * Default logger instance for general use.
- */
-export const log = createLogger("qwen");