rush-ai 0.2.0

package/dist/chunk-7H2T3KCJ.js

@@ -0,0 +1,870 @@
+#!/usr/bin/env node
+
+// src/output/logger.ts
+import chalk from "chalk";
+var output = {
+  /** Content output → stdout. Use for data the user may pipe/redirect. */
+  log(message) {
+    console.log(message);
+  },
+  /** Status → stderr */
+  success(message) {
+    console.error(chalk.green("Success!"), message);
+  },
+  /** Error → stderr */
+  error(message) {
+    console.error(chalk.red("Error:"), message);
+  },
+  /** Warning → stderr */
+  warn(message) {
+    console.error(chalk.yellow("Warning:"), message);
+  },
+  /** Info → stderr */
+  info(message) {
+    console.error(chalk.cyan("Info:"), message);
+  },
+  /** Dim status → stderr */
+  dim(message) {
+    console.error(chalk.dim(message));
+  },
+  table(data) {
+    console.table(data);
+  },
+  /** Newline → stderr (status separator) */
+  newline() {
+    console.error();
+  },
+  link(text, url) {
+    return chalk.cyan.underline(url);
+  },
+  bold(text) {
+    return chalk.bold(text);
+  }
+};
+
+// src/version.ts
+import { readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+function loadVersion() {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  const candidates = [
+    resolve(__dirname, "..", "package.json"),
+    resolve(__dirname, "..", "..", "package.json")
+  ];
+  for (const candidate of candidates) {
+    try {
+      const pkg = JSON.parse(readFileSync(candidate, "utf-8"));
+      if (pkg.name === "rush-ai" && pkg.version) {
+        return pkg.version;
+      }
+    } catch {
+    }
+  }
+  console.error("[rush-ai] Warning: Could not read version from package.json");
+  return "0.0.0-unknown";
+}
+var VERSION = loadVersion();
+
+// src/util/config.ts
+import { homedir } from "os";
+import { resolve as resolve2 } from "path";
+import Conf from "conf";
+var AUTH_CONFIG_DIR = resolve2(homedir(), ".rush");
+var DEFAULT_API = "https://rush.zhenguanyu.com";
+var AUTH_DEFAULTS = {
+  token: null,
+  expiresAt: null,
+  refreshToken: null,
+  method: null,
+  tokenId: null
+};
+var GLOBAL_DEFAULTS = {
+  currentTeam: null,
+  api: DEFAULT_API,
+  collectMetrics: true
+};
+var globalStore = new Conf({
+  projectName: "rush-ai",
+  cwd: AUTH_CONFIG_DIR,
+  configName: "config",
+  defaults: {}
+});
+var authStore = new Conf({
+  projectName: "rush-ai",
+  cwd: AUTH_CONFIG_DIR,
+  configName: "auth",
+  defaults: {}
+});
+function migrateGlobalStoreIfNeeded() {
+  const version = globalStore.get("_version");
+  if (version === 2) return;
+  const hasOldFormat = globalStore.has("api") && !globalStore.has("profiles");
+  const isEmpty = globalStore.size === 0;
+  if (hasOldFormat) {
+    const oldConfig = {
+      currentTeam: globalStore.get("currentTeam") ?? null,
+      api: globalStore.get("api") ?? DEFAULT_API,
+      collectMetrics: globalStore.get("collectMetrics") ?? true
+    };
+    globalStore.clear();
+    globalStore.set("_version", 2);
+    globalStore.set("activeProfile", "default");
+    globalStore.set("profiles", { default: oldConfig });
+  } else if (isEmpty || !globalStore.has("profiles")) {
+    globalStore.set("_version", 2);
+    if (!globalStore.has("activeProfile")) {
+      globalStore.set("activeProfile", "default");
+    }
+    if (!globalStore.has("profiles")) {
+      globalStore.set("profiles", { default: { ...GLOBAL_DEFAULTS } });
+    }
+  }
+}
+function migrateAuthStoreIfNeeded() {
+  const version = authStore.get("_version");
+  if (version === 2) return;
+  const hasOldFormat = authStore.has("token") || authStore.has("method");
+  const isEmpty = authStore.size === 0;
+  if (hasOldFormat) {
+    const oldAuth = {
+      token: authStore.get("token") ?? null,
+      expiresAt: authStore.get("expiresAt") ?? null,
+      refreshToken: authStore.get("refreshToken") ?? null,
+      method: authStore.get("method") ?? null,
+      tokenId: authStore.get("tokenId") ?? null
+    };
+    authStore.clear();
+    authStore.set("_version", 2);
+    authStore.set("default", oldAuth);
+  } else if (isEmpty) {
+    authStore.set("_version", 2);
+  }
+}
+migrateGlobalStoreIfNeeded();
+migrateAuthStoreIfNeeded();
+function getActiveProfile() {
+  return process.env.RUSH_PROFILE ?? globalStore.get("activeProfile") ?? "default";
+}
+function setActiveProfile(name) {
+  const profiles = globalStore.get("profiles") ?? {};
+  if (!profiles[name]) {
+    throw new Error(
+      `Profile '${name}' does not exist. Available: ${Object.keys(profiles).join(", ")}`
+    );
+  }
+  globalStore.set("activeProfile", name);
+}
+function listProfiles() {
+  const profiles = globalStore.get("profiles") ?? {};
+  return Object.keys(profiles);
+}
+function createProfile(name, config) {
+  const profiles = globalStore.get("profiles") ?? {};
+  if (profiles[name]) {
+    throw new Error(`Profile '${name}' already exists.`);
+  }
+  const defaultConfig = profiles.default ?? GLOBAL_DEFAULTS;
+  profiles[name] = { ...defaultConfig, ...config };
+  globalStore.set("profiles", profiles);
+}
+function deleteProfile(name) {
+  if (name === "default") {
+    throw new Error("Cannot delete the 'default' profile.");
+  }
+  const active = getActiveProfile();
+  if (name === active) {
+    throw new Error(
+      `Cannot delete the active profile '${name}'. Switch to another profile first.`
+    );
+  }
+  const profiles = globalStore.get("profiles") ?? {};
+  if (!profiles[name]) {
+    throw new Error(`Profile '${name}' does not exist.`);
+  }
+  delete profiles[name];
+  globalStore.set("profiles", profiles);
+  authStore.delete(name);
+}
+function getAuthConfig() {
+  const profile = getActiveProfile();
+  const profileAuth = authStore.get(profile);
+  return {
+    token: profileAuth?.token ?? null,
+    expiresAt: profileAuth?.expiresAt ?? null,
+    refreshToken: profileAuth?.refreshToken ?? null,
+    method: profileAuth?.method ?? null,
+    tokenId: profileAuth?.tokenId ?? null
+  };
+}
+function setAuthConfig(config) {
+  const profile = getActiveProfile();
+  const current = authStore.get(profile) ?? {
+    ...AUTH_DEFAULTS
+  };
+  authStore.set(profile, { ...current, ...config });
+}
+function clearAuthConfig() {
+  const profile = getActiveProfile();
+  authStore.set(profile, { ...AUTH_DEFAULTS });
+}
+function getGlobalConfig() {
+  const profile = getActiveProfile();
+  const profiles = globalStore.get("profiles") ?? {};
+  const profileConfig = profiles[profile] ?? GLOBAL_DEFAULTS;
+  return {
+    currentTeam: profileConfig.currentTeam ?? null,
+    api: profileConfig.api ?? DEFAULT_API,
+    collectMetrics: profileConfig.collectMetrics ?? true
+  };
+}
+function setGlobalConfig(config) {
+  const profile = getActiveProfile();
+  const profiles = globalStore.get("profiles") ?? {};
+  const current = profiles[profile] ?? { ...GLOBAL_DEFAULTS };
+  profiles[profile] = { ...current, ...config };
+  globalStore.set("profiles", profiles);
+}
+function getConfigDir() {
+  return AUTH_CONFIG_DIR;
+}
+function isLoggedIn() {
+  const auth = getAuthConfig();
+  if (!auth.token) return false;
+  if (auth.expiresAt && Date.now() > auth.expiresAt) {
+    return auth.method === "cas" && Boolean(auth.refreshToken);
+  }
+  return true;
+}
+function getProfileConfig(name) {
+  const profiles = globalStore.get("profiles") ?? {};
+  return profiles[name] ?? null;
+}
+function getProfileAuth(name) {
+  const profileAuth = authStore.get(name);
+  return {
+    token: profileAuth?.token ?? null,
+    expiresAt: profileAuth?.expiresAt ?? null,
+    refreshToken: profileAuth?.refreshToken ?? null,
+    method: profileAuth?.method ?? null,
+    tokenId: profileAuth?.tokenId ?? null
+  };
+}
+
+// src/util/auth.ts
+function getAuthMethod() {
+  if (process.env.RUSH_API_KEY) {
+    return "api_key";
+  }
+  const auth = getAuthConfig();
+  if (auth.token) {
+    if (auth.method === "api_key" || auth.token.startsWith("rush_sk_")) {
+      return "api_key";
+    }
+    if (auth.method === "platform_token") {
+      return "platform_token";
+    }
+    return auth.method ?? "cas";
+  }
+  return null;
+}
+function getAuthToken() {
+  if (process.env.RUSH_API_KEY) {
+    return process.env.RUSH_API_KEY;
+  }
+  const auth = getAuthConfig();
+  return auth.token;
+}
+function getCasConfig() {
+  const config = getGlobalConfig();
+  const baseUrl = process.env.RUSH_API_URL ?? config.api;
+  return {
+    authorizeEndpoint: process.env.RUSH_CAS_AUTHORIZE_ENDPOINT ?? `${baseUrl}/cas/oauth2/authorize`,
+    tokenEndpoint: process.env.RUSH_CAS_TOKEN_ENDPOINT ?? `${baseUrl}/cas/oauth2/token`,
+    revokeEndpoint: process.env.RUSH_CAS_REVOKE_ENDPOINT ?? `${baseUrl}/cas/oauth2/revoke`,
+    clientId: process.env.RUSH_CAS_CLIENT_ID ?? "rush-ai"
+  };
+}
+
+// src/util/auth-session.ts
+var VERIFY_PATH = "/api/skill-auth/me";
+var REFRESH_SKEW_MS = 6e4;
+var AUTH_REQUEST_TIMEOUT_MS = 8e3;
+function getApiBaseUrl() {
+  return process.env.RUSH_API_URL ?? getGlobalConfig().api;
+}
+function buildBearerHeaders(token) {
+  return {
+    Authorization: `Bearer ${token}`,
+    "Content-Type": "application/json",
+    "User-Agent": "rush-ai/0.2.0"
+  };
+}
+function shouldRefreshToken(options) {
+  const auth = getAuthConfig();
+  if (!auth.token || auth.method !== "cas" || !auth.refreshToken) {
+    return false;
+  }
+  if (options?.force) {
+    return true;
+  }
+  if (!auth.expiresAt) {
+    return false;
+  }
+  const refreshWindowMs = options?.refreshWindowMs ?? REFRESH_SKEW_MS;
+  return Date.now() >= auth.expiresAt - refreshWindowMs;
+}
+async function refreshCasAccessToken(options) {
+  if (process.env.RUSH_API_KEY || !shouldRefreshToken(options)) {
+    return false;
+  }
+  const auth = getAuthConfig();
+  if (!auth.refreshToken) {
+    return false;
+  }
+  const cas = getCasConfig();
+  const body = new URLSearchParams({
+    grant_type: "refresh_token",
+    refresh_token: auth.refreshToken,
+    client_id: cas.clientId
+  }).toString();
+  try {
+    const response = await fetch(cas.tokenEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body,
+      signal: AbortSignal.timeout(AUTH_REQUEST_TIMEOUT_MS)
+    });
+    if (!response.ok) {
+      return false;
+    }
+    const tokenData = await response.json();
+    if (!tokenData.access_token) {
+      return false;
+    }
+    const expiresAt = tokenData.expires_in ? Date.now() + tokenData.expires_in * 1e3 : auth.expiresAt;
+    setAuthConfig({
+      token: tokenData.access_token,
+      expiresAt,
+      refreshToken: tokenData.refresh_token ?? auth.refreshToken,
+      method: "cas"
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function verifyTokenOnline(token) {
+  const url = `${getApiBaseUrl()}${VERIFY_PATH}`;
+  try {
+    const response = await fetch(url, {
+      method: "GET",
+      headers: buildBearerHeaders(token),
+      signal: AbortSignal.timeout(AUTH_REQUEST_TIMEOUT_MS)
+    });
+    if (response.ok) {
+      return { valid: true, status: response.status };
+    }
+    const message = await response.text().catch(() => void 0);
+    return {
+      valid: false,
+      status: response.status,
+      message: message || `Server rejected token (${response.status})`
+    };
+  } catch (error) {
+    return {
+      valid: false,
+      status: null,
+      message: `Network error: ${error instanceof Error ? error.message : "unknown"}`
+    };
+  }
+}
+async function verifyCurrentAuthSession() {
+  const token = getAuthToken();
+  if (!token) {
+    return {
+      valid: false,
+      status: null,
+      message: "Not authenticated"
+    };
+  }
+  await refreshCasAccessToken();
+  let activeToken = getAuthToken();
+  if (!activeToken) {
+    return {
+      valid: false,
+      status: null,
+      message: "Not authenticated"
+    };
+  }
+  const result = await verifyTokenOnline(activeToken);
+  if (result.valid || result.status !== 401 || process.env.RUSH_API_KEY) {
+    return result;
+  }
+  const refreshed = await refreshCasAccessToken({ force: true });
+  if (!refreshed) {
+    return result;
+  }
+  activeToken = getAuthToken();
+  if (!activeToken) {
+    return result;
+  }
+  return verifyTokenOnline(activeToken);
+}
+async function revokeToken(revokeEndpoint, clientId, token, tokenTypeHint) {
+  const body = new URLSearchParams({
+    token,
+    token_type_hint: tokenTypeHint,
+    client_id: clientId
+  }).toString();
+  try {
+    const response = await fetch(revokeEndpoint, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body,
+      signal: AbortSignal.timeout(AUTH_REQUEST_TIMEOUT_MS)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+async function revokeCurrentSession() {
+  if (process.env.RUSH_API_KEY) {
+    return false;
+  }
+  const auth = getAuthConfig();
+  if (auth.method === "platform_token") {
+    return revokePlatformToken();
+  }
+  if (auth.method !== "cas") {
+    return false;
+  }
+  const cas = getCasConfig();
+  const candidates = [];
+  if (auth.refreshToken) {
+    candidates.push({ token: auth.refreshToken, hint: "refresh_token" });
+  }
+  if (auth.token) {
+    candidates.push({ token: auth.token, hint: "access_token" });
+  }
+  if (candidates.length === 0) {
+    return false;
+  }
+  let anyRevoked = false;
+  for (const candidate of candidates) {
+    const revoked = await revokeToken(
+      cas.revokeEndpoint,
+      cas.clientId,
+      candidate.token,
+      candidate.hint
+    );
+    if (revoked) {
+      anyRevoked = true;
+    }
+  }
+  return anyRevoked;
+}
+async function revokePlatformToken() {
+  const auth = getAuthConfig();
+  if (!auth.tokenId || !auth.token) {
+    return false;
+  }
+  const baseUrl = getApiBaseUrl();
+  const url = `${baseUrl}/api/platform-tokens?id=${encodeURIComponent(auth.tokenId)}`;
+  try {
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: {
+        Authorization: `Bearer ${auth.token}`,
+        "User-Agent": "rush-ai/0.2.0"
+      },
+      signal: AbortSignal.timeout(AUTH_REQUEST_TIMEOUT_MS)
+    });
+    return response.ok;
+  } catch {
+    return false;
+  }
+}
+
+// src/util/errors.ts
+var RushError = class extends Error {
+  code;
+  meta;
+  exitCode;
+  constructor(message, meta = {}, code = "RUSH_ERROR", exitCode = 2) {
+    super(message);
+    this.name = "RushError";
+    this.code = code;
+    this.meta = meta;
+    this.exitCode = exitCode;
+  }
+};
+var AuthError = class extends RushError {
+  constructor(message = "Not authenticated. Run `rush-ai auth login` first.") {
+    super(message, {}, "AUTH_ERROR", 3);
+    this.name = "AuthError";
+  }
+};
+var TaskFailedError = class extends RushError {
+  constructor(message, meta = {}) {
+    super(message, meta, "TASK_FAILED", 1);
+    this.name = "TaskFailedError";
+  }
+};
+function friendlyMessage(status, serverMessage) {
+  if (serverMessage) return serverMessage;
+  switch (status) {
+    case 401:
+      return "Authentication expired. Run `rush-ai auth login` to re-authenticate.";
+    case 403:
+      return "Permission denied. You may not have access to this resource.";
+    case 404:
+      return "Resource not found.";
+    case 429:
+      return "Rate limited. The server is busy, please try again later.";
+    case 502:
+    case 503:
+    case 504:
+      return "Service temporarily unavailable. Please try again in a moment.";
+    default:
+      return `Request failed with status ${status}.`;
+  }
+}
+var ApiError = class extends RushError {
+  status;
+  retryAfter;
+  constructor(message, status, body, retryAfter) {
+    let serverMessage;
+    if (body) {
+      try {
+        const parsed = JSON.parse(body);
+        if (parsed.error && typeof parsed.error === "string") {
+          serverMessage = parsed.error;
+        }
+      } catch {
+      }
+    }
+    super(
+      friendlyMessage(status, serverMessage),
+      { status, body },
+      "API_ERROR"
+    );
+    this.name = "ApiError";
+    this.status = status;
+    this.retryAfter = retryAfter;
+  }
+};
+function isRushError(error) {
+  return error instanceof RushError;
+}
+
+// src/util/retry.ts
+function parseRetryAfter(value) {
+  const seconds = Number(value);
+  if (!Number.isNaN(seconds) && seconds >= 0) {
+    return seconds * 1e3;
+  }
+  const date = new Date(value);
+  if (!Number.isNaN(date.getTime())) {
+    const delayMs = date.getTime() - Date.now();
+    return delayMs > 0 ? delayMs : 0;
+  }
+  return null;
+}
+function calculateDelay(attempt, baseDelay, maxDelay) {
+  const exponential = baseDelay * 2 ** attempt;
+  const jitter = Math.random() * baseDelay * 0.5;
+  return Math.min(exponential + jitter, maxDelay);
+}
+function isRetryableError(error, retryableStatuses) {
+  if (error instanceof RushError && error.code === "NETWORK_ERROR") {
+    return true;
+  }
+  if (error instanceof ApiError && retryableStatuses.includes(error.status)) {
+    return true;
+  }
+  return false;
+}
+function getRetryAfterFromError(error) {
+  if (error instanceof ApiError && error.status === 429) {
+    if (error.retryAfter) {
+      return parseRetryAfter(error.retryAfter);
+    }
+  }
+  return null;
+}
+async function withRetry(fn, options = {}) {
+  const {
+    maxRetries = 3,
+    baseDelay = 1e3,
+    maxDelay = 3e4,
+    retryableStatuses = [429, 502, 503, 504],
+    signal,
+    onRetry
+  } = options;
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    if (signal?.aborted) {
+      throw lastError ?? new RushError("Request aborted", {}, "ABORT_ERROR");
+    }
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxRetries) {
+        throw error;
+      }
+      if (!isRetryableError(error, retryableStatuses)) {
+        throw error;
+      }
+      if (signal?.aborted) {
+        throw error;
+      }
+      let delayMs;
+      const retryAfterMs = getRetryAfterFromError(error);
+      if (retryAfterMs !== null) {
+        delayMs = Math.min(retryAfterMs, 12e4);
+      } else {
+        delayMs = calculateDelay(attempt, baseDelay, maxDelay);
+      }
+      const status = error instanceof ApiError ? error.status : void 0;
+      onRetry?.(attempt + 1, delayMs, status);
+      await new Promise((resolve3, reject) => {
+        const timer = setTimeout(resolve3, delayMs);
+        if (signal) {
+          const onAbort = () => {
+            clearTimeout(timer);
+            reject(lastError);
+          };
+          signal.addEventListener("abort", onAbort, { once: true });
+          const origResolve = resolve3;
+          setTimeout(() => {
+            signal.removeEventListener("abort", onAbort);
+            origResolve();
+          }, delayMs);
+        }
+      });
+    }
+  }
+  throw lastError;
+}
+
+// src/util/verbosity.ts
+var _verbose = false;
+var _debug = false;
+function setVerbosity(verbose, debug) {
+  _debug = debug;
+  _verbose = verbose || debug;
+}
+var isVerbose = () => _verbose;
+var isDebug = () => _debug;
+
+// src/util/client.ts
+var SENSITIVE_HEADERS = [
+  "authorization",
+  "cookie",
+  "set-cookie",
+  "x-api-key"
+];
+function maskSensitiveHeaders(headers) {
+  const result = {};
+  headers.forEach((value, key) => {
+    result[key] = SENSITIVE_HEADERS.includes(key.toLowerCase()) ? "[REDACTED]" : value;
+  });
+  return result;
+}
+var RushClient = class _RushClient {
+  baseUrl;
+  constructor() {
+    const config = getGlobalConfig();
+    const raw = process.env.RUSH_API_URL ?? config.api;
+    this.baseUrl = raw.replace(/\/+$/, "");
+  }
+  async getHeaders() {
+    const headers = {
+      "Content-Type": "application/json",
+      "User-Agent": `rush-ai/${VERSION}`
+    };
+    if (!process.env.RUSH_API_KEY) {
+      await refreshCasAccessToken();
+    }
+    const token = getAuthToken();
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    }
+    if (process.env.RUSH_TEST_MODE === "integration-test") {
+      headers["X-Test-Mode"] = "integration-test";
+    }
+    return headers;
+  }
+  async performRequest(url, options, retryOnUnauthorized = true) {
+    const requestHeaders = options.headers ?? {};
+    const headers = await this.getHeaders();
+    try {
+      const response = await fetch(url, {
+        ...options,
+        headers: {
+          ...headers,
+          ...requestHeaders
+        }
+      });
+      if (response.status === 401 && retryOnUnauthorized && !process.env.RUSH_API_KEY) {
+        const auth = getAuthConfig();
+        const canRefresh = auth.method === "cas" && Boolean(auth.refreshToken);
+        if (canRefresh && await refreshCasAccessToken({ force: true })) {
+          const retryHeaders = await this.getHeaders();
+          return await fetch(url, {
+            ...options,
+            headers: {
+              ...retryHeaders,
+              ...requestHeaders
+            }
+          });
+        }
+      }
+      return response;
+    } catch (err) {
+      throw new RushError(
+        `Network error: ${err instanceof Error ? err.message : "Failed to connect"}`,
+        { url },
+        "NETWORK_ERROR"
+      );
+    }
+  }
+  /** Idempotent HTTP methods eligible for automatic retry */
+  static RETRYABLE_METHODS = ["GET", "HEAD", "DELETE"];
+  /**
+   * Internal fetch with response parsing and error handling (no retry).
+   */
+  async _doFetch(path, options = {}) {
+    const { json = true, ...fetchOptions } = options;
+    const url = `${this.baseUrl}${path}`;
+    const method = (fetchOptions.method ?? "GET").toUpperCase();
+    const startTime = Date.now();
+    if (isVerbose()) {
+      output.dim(`\u2192 ${method} ${url}`);
+    }
+    const response = await this.performRequest(url, fetchOptions);
+    if (isVerbose()) {
+      output.dim(
+        `\u2190 ${response.status} ${response.statusText} (${Date.now() - startTime}ms)`
+      );
+    }
+    if (isDebug()) {
+      output.dim(
+        `  Response headers: ${JSON.stringify(maskSensitiveHeaders(response.headers))}`
+      );
+    }
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "Unknown error");
+      const retryAfter = response.headers.get("retry-after") ?? void 0;
+      throw new ApiError(
+        `API request failed: ${response.status} ${response.statusText}`,
+        response.status,
+        errorBody,
+        retryAfter
+      );
+    }
+    const data = json ? await response.json() : await response.text();
+    return {
+      ok: true,
+      status: response.status,
+      data
+    };
+  }
+  /**
+   * Fetch with response parsing, error handling, and automatic retry
+   * for idempotent methods (GET, HEAD, DELETE).
+   */
+  async fetch(path, options = {}) {
+    const method = (options.method ?? "GET").toUpperCase();
+    const isRetryable = _RushClient.RETRYABLE_METHODS.includes(method);
+    if (!isRetryable) {
+      return this._doFetch(path, options);
+    }
+    return withRetry(() => this._doFetch(path, options), {
+      signal: options.signal ?? void 0,
+      onRetry: (attempt, delayMs, status) => {
+        const statusInfo = status ? ` (${status})` : "";
+        console.error(
+          `\u27F3 Retrying ${method} ${path}${statusInfo} (attempt ${attempt}) in ${(delayMs / 1e3).toFixed(1)}s...`
+        );
+      }
+    });
+  }
+  /**
+   * Raw fetch for streaming (SSE) responses.
+   * Returns the raw Response object.
+   */
+  async fetchRaw(path, options = {}) {
+    const url = `${this.baseUrl}${path}`;
+    const response = await this.performRequest(url, options);
+    if (!response.ok) {
+      const errorBody = await response.text().catch(() => "Unknown error");
+      throw new ApiError(
+        `API request failed: ${response.status} ${response.statusText}`,
+        response.status,
+        errorBody
+      );
+    }
+    return response;
+  }
+  async get(path) {
+    return this.fetch(path, { method: "GET" });
+  }
+  async post(path, body) {
+    return this.fetch(path, {
+      method: "POST",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  async put(path, body) {
+    return this.fetch(path, {
+      method: "PUT",
+      body: body ? JSON.stringify(body) : void 0
+    });
+  }
+  async delete(path) {
+    return this.fetch(path, { method: "DELETE" });
+  }
+};
+function createClient() {
+  return new RushClient();
+}
+
+export {
+  output,
+  VERSION,
+  getActiveProfile,
+  setActiveProfile,
+  listProfiles,
+  createProfile,
+  deleteProfile,
+  getAuthConfig,
+  setAuthConfig,
+  clearAuthConfig,
+  getGlobalConfig,
+  setGlobalConfig,
+  getConfigDir,
+  isLoggedIn,
+  getProfileConfig,
+  getProfileAuth,
+  getAuthMethod,
+  getAuthToken,
+  verifyCurrentAuthSession,
+  revokeCurrentSession,
+  RushError,
+  AuthError,
+  TaskFailedError,
+  ApiError,
+  isRushError,
+  setVerbosity,
+  RushClient,
+  createClient
+};
+//# sourceMappingURL=chunk-7H2T3KCJ.js.map