@dotobokuri/fleet-console 1.38.0 → 1.40.0

package/dist/fleet-plugins/quota/routes.mjs

@@ -0,0 +1,672 @@
+#!/usr/bin/env node
+import { execFile } from 'child_process';
+import { constants } from 'fs';
+import fs from 'fs/promises';
+import os from 'os';
+import path from 'path';
+import { promisify } from 'util';
+
+// sdk/plugin/node.ts
+function definePlugin(definition) {
+  return definition;
+}
+function registerRouter(ctx, path2, handler) {
+  ctx.registerRouter(normalizePath(path2), handler);
+}
+function normalizePath(path2) {
+  if (path2.length === 0 || path2 === "/") return "/";
+  return path2;
+}
+
+// ../fleet-plugins/quota/server/handlers.ts
+async function handleSummary(req, res, ctx, service) {
+  if (req.method !== "GET") {
+    ctx.host.http.writeJson(res, 405, { error: "method_not_allowed" });
+    return;
+  }
+  if (!ctx.host.security.isTerminalAuthorized(req)) {
+    ctx.host.http.writeJson(res, 401, { error: "unauthorized" });
+    return;
+  }
+  const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+  ctx.host.http.writeJson(res, 200, await service.getSummary({ force: url.searchParams.get("force") === "1" }));
+}
+async function handleConnect(req, res, ctx, service, serializeSettings) {
+  if (req.method !== "POST") {
+    ctx.host.http.writeJson(res, 405, { error: "method_not_allowed" });
+    return;
+  }
+  if (!ctx.host.security.isTerminalAuthorized(req)) {
+    ctx.host.http.writeJson(res, 401, { error: "unauthorized" });
+    return;
+  }
+  const contentType = req.headers["content-type"];
+  const mediaType = typeof contentType === "string" ? contentType.split(";", 1)[0]?.trim().toLowerCase() : void 0;
+  if (mediaType !== "application/json") {
+    ctx.host.http.writeJson(res, 415, { error: "unsupported_media_type" });
+    return;
+  }
+  let body;
+  try {
+    body = await ctx.host.http.readJsonBody(req);
+  } catch {
+    body = null;
+  }
+  if (!body || Object.keys(body).length !== 2 || body.provider !== "claude" && body.provider !== "cursor" || typeof body.connected !== "boolean") {
+    ctx.host.http.writeJson(res, 400, { error: "invalid_connect_request" });
+    return;
+  }
+  await serializeSettings(async () => {
+    const stored = await ctx.host.storage.readJson("quota", "settings");
+    const settings = stored !== null && typeof stored === "object" && !Array.isArray(stored) ? stored : {};
+    const next = {
+      ...typeof settings.claudeConnected === "boolean" ? { claudeConnected: settings.claudeConnected } : {},
+      ...typeof settings.cursorConnected === "boolean" ? { cursorConnected: settings.cursorConnected } : {},
+      ...body.provider === "claude" ? { claudeConnected: body.connected } : { cursorConnected: body.connected }
+    };
+    await ctx.host.storage.writeJson("quota", "settings", next);
+  });
+  ctx.host.http.writeJson(res, 200, await service.getSummary({ forceProvider: body.provider }));
+}
+var execFileAsync = promisify(execFile);
+var MAX_CREDENTIAL_BYTES = 65536;
+var CREDENTIAL_OPEN_FLAGS = process.platform === "win32" ? constants.O_RDONLY : constants.O_RDONLY | constants.O_NONBLOCK;
+async function readBoundedFile(filePath, maxBytes) {
+  const handle = await fs.open(filePath, CREDENTIAL_OPEN_FLAGS);
+  try {
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size > maxBytes) return null;
+    const buffer = Buffer.allocUnsafe(maxBytes + 1);
+    let totalBytes = 0;
+    while (totalBytes < buffer.byteLength) {
+      const { bytesRead } = await handle.read(
+        buffer,
+        totalBytes,
+        buffer.byteLength - totalBytes,
+        totalBytes
+      );
+      if (bytesRead === 0) break;
+      totalBytes += bytesRead;
+    }
+    return totalBytes > maxBytes ? null : buffer.subarray(0, totalBytes).toString("utf8");
+  } finally {
+    await handle.close();
+  }
+}
+var defaultCredentialDeps = {
+  platform: process.platform,
+  homedir: os.homedir,
+  env: process.env,
+  readBounded: readBoundedFile,
+  execFile: async (file, args, options) => {
+    const result = await execFileAsync(file, [...args], options);
+    return result.stdout;
+  }
+};
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function optionalString(value) {
+  return typeof value === "string" && value.length > 0 ? value : void 0;
+}
+function optionalTrimmedString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed.length > 0 ? trimmed : void 0;
+}
+function optionalEpoch(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0 ? value : void 0;
+}
+function parseClaudeCredentialJson(raw, method) {
+  if (raw.length > MAX_CREDENTIAL_BYTES) return null;
+  try {
+    const parsed = record(JSON.parse(raw));
+    if (!parsed) return null;
+    const oauth = record(parsed.claudeAiOauth);
+    const accessToken = optionalString(oauth?.accessToken ?? parsed.accessToken);
+    if (!accessToken) return null;
+    return {
+      accessToken,
+      expiresAt: optionalEpoch(oauth?.expiresAt ?? parsed.expiresAt),
+      subscriptionType: optionalString(oauth?.subscriptionType ?? parsed.subscriptionType),
+      method
+    };
+  } catch {
+    return null;
+  }
+}
+async function resolveClaudeCredentials(deps) {
+  if (deps.platform === "darwin") {
+    try {
+      const raw = await deps.execFile(
+        "security",
+        ["find-generic-password", "-s", "Claude Code-credentials", "-w"],
+        { timeout: 5e3 }
+      );
+      const credential = raw.length <= MAX_CREDENTIAL_BYTES ? parseClaudeCredentialJson(raw, "keychain") : null;
+      if (credential) return credential;
+    } catch {
+    }
+  }
+  const configDir = deps.env.CLAUDE_CONFIG_DIR || path.join(deps.homedir(), ".claude");
+  try {
+    const raw = await deps.readBounded(path.join(configDir, ".credentials.json"), MAX_CREDENTIAL_BYTES);
+    return raw === null || raw.length > MAX_CREDENTIAL_BYTES ? null : parseClaudeCredentialJson(raw, "file");
+  } catch {
+    return null;
+  }
+}
+async function resolveCodexCredentials(deps) {
+  const home = deps.env.CODEX_HOME || path.join(deps.homedir(), ".codex");
+  try {
+    const raw = await deps.readBounded(path.join(home, "auth.json"), MAX_CREDENTIAL_BYTES);
+    if (raw === null || raw.length > MAX_CREDENTIAL_BYTES) return null;
+    const parsed = record(JSON.parse(raw));
+    const tokens = record(parsed?.tokens);
+    const accessToken = optionalString(tokens?.access_token);
+    if (!accessToken) return null;
+    return { accessToken, accountId: optionalString(tokens?.account_id) };
+  } catch {
+    return null;
+  }
+}
+function parseCursorCredentialJson(raw, method) {
+  if (raw.length > MAX_CREDENTIAL_BYTES) return null;
+  try {
+    const parsed = record(JSON.parse(raw));
+    if (!parsed) return null;
+    const tokens = record(parsed.tokens);
+    const cursorAuth = record(parsed.cursorAuth);
+    const accessToken = [
+      parsed.accessToken,
+      parsed.access_token,
+      tokens?.accessToken,
+      tokens?.access_token,
+      cursorAuth?.accessToken,
+      cursorAuth?.access_token
+    ].map(optionalTrimmedString).find((value) => value !== void 0);
+    return accessToken ? { accessToken, method } : null;
+  } catch {
+    return null;
+  }
+}
+async function resolveCursorCredentials(deps) {
+  if (deps.platform === "darwin") {
+    try {
+      const raw = await deps.execFile(
+        "security",
+        ["find-generic-password", "-s", "cursor-access-token", "-a", "cursor-user", "-w"],
+        { timeout: 5e3 }
+      );
+      const accessToken = raw.length <= MAX_CREDENTIAL_BYTES ? optionalTrimmedString(raw) : void 0;
+      if (accessToken) return { accessToken, method: "keychain" };
+    } catch {
+    }
+  }
+  const home = deps.homedir();
+  const authFile = deps.platform === "win32" ? path.join(deps.env.APPDATA || path.join(home, "AppData", "Roaming"), "Cursor", "auth.json") : deps.platform === "darwin" ? path.join(home, ".cursor", "auth.json") : path.join(deps.env.XDG_CONFIG_HOME || path.join(home, ".config"), "cursor", "auth.json");
+  try {
+    const raw = await deps.readBounded(authFile, MAX_CREDENTIAL_BYTES);
+    return raw === null || raw.length > MAX_CREDENTIAL_BYTES ? null : parseCursorCredentialJson(raw, "file");
+  } catch {
+    return null;
+  }
+}
+
+// ../fleet-plugins/quota/server/providers.ts
+var REQUEST_TIMEOUT_MS = 1e4;
+var MAX_RESPONSE_BYTES = 262144;
+var MAX_WINDOWS = 8;
+var MAX_CREDIT_ENTRIES = 256;
+var ProviderHttpError = class extends Error {
+  constructor(statusCode) {
+    super(statusCode === void 0 ? "Provider request failed" : `Provider request failed (${statusCode})`);
+    this.statusCode = statusCode;
+  }
+  statusCode;
+};
+var ProviderResponseTooLargeError = class extends Error {
+  constructor() {
+    super("Provider response too large");
+  }
+};
+function object(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function array(value) {
+  return Array.isArray(value) ? value : [];
+}
+function safeTimestamp(value) {
+  let result;
+  if (typeof value === "number" && Number.isFinite(value)) result = value < 1e12 ? value * 1e3 : value;
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (/^[1-9]\d{9,14}$/.test(trimmed)) {
+      const parsed = Number(trimmed);
+      if (Number.isFinite(parsed)) result = parsed < 1e12 ? parsed * 1e3 : parsed;
+    } else {
+      const parsed = Date.parse(value);
+      if (Number.isFinite(parsed)) result = parsed;
+    }
+  }
+  if (result === void 0 || !Number.isFinite(result) || result < 0) return void 0;
+  const rounded = Math.round(result);
+  return Number.isSafeInteger(rounded) ? rounded : void 0;
+}
+function percent(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  return Math.min(100, Math.max(0, Math.round(value)));
+}
+function validatedString(value, pattern) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  if (!pattern.test(trimmed)) return void 0;
+  if (/^bearer /i.test(trimmed)) return void 0;
+  if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(trimmed)) return void 0;
+  if (/^[A-Za-z0-9_-]+\.[A-Za-z0-9_-]+\.[A-Za-z0-9_-]*$/.test(trimmed)) return void 0;
+  return trimmed;
+}
+function titleCase(value) {
+  const validated = validatedString(value, /^[A-Za-z0-9][A-Za-z0-9 .+-]{0,23}$/);
+  if (!validated) return void 0;
+  if (/^\d+$/.test(validated)) return void 0;
+  return `${validated[0]?.toUpperCase() ?? ""}${validated.slice(1)}`;
+}
+function modelLabel(value) {
+  return validatedString(value, /^[A-Za-z0-9][A-Za-z0-9 .+-]{0,39}$/) ?? "Model";
+}
+function firstClaudePercent(row) {
+  for (const key of ["percent", "used_percentage", "utilization"]) {
+    const value = row[key];
+    if (typeof value === "number" && Number.isFinite(value)) return percent(value);
+  }
+  return void 0;
+}
+function claudeWindow(id, source, label) {
+  const row = object(source);
+  if (!row) return null;
+  const usedPercent = firstClaudePercent(row);
+  if (usedPercent === void 0) return null;
+  const resetsAt = safeTimestamp(row.resets_at);
+  return {
+    id,
+    ...label ? { label } : {},
+    usedPercent,
+    ...resetsAt !== void 0 ? { resetsAt } : {}
+  };
+}
+function parseClaudeUsage(payload) {
+  const root = object(payload) ?? {};
+  const namedSession = claudeWindow("session", root.five_hour);
+  const namedWeekly = claudeWindow("weekly", root.seven_day);
+  let fallbackSession = null;
+  let fallbackWeekly = null;
+  const modelWindows = [];
+  const limits = array(root.limits);
+  for (let index = 0; index < limits.length && index < MAX_CREDIT_ENTRIES; index += 1) {
+    const item = limits[index];
+    const limit = object(item);
+    if (!limit) continue;
+    if (limit.kind === "session" && !namedSession && !fallbackSession) {
+      fallbackSession = claudeWindow("session", limit);
+      continue;
+    }
+    if (limit.kind === "weekly_all" && !namedWeekly && !fallbackWeekly) {
+      fallbackWeekly = claudeWindow("weekly", limit);
+      continue;
+    }
+    if (limit.kind === "weekly_scoped" && modelWindows.length < MAX_WINDOWS) {
+      const model = object(object(limit.scope)?.model);
+      const row = claudeWindow("model", limit, modelLabel(model?.display_name));
+      if (row) modelWindows.push(row);
+    }
+  }
+  if (modelWindows.length === 0) {
+    for (const alias of [root.fable_weekly, root.fable_seven_day, root.seven_day_fable]) {
+      const row = claudeWindow("model", alias, "Fable");
+      if (row) {
+        modelWindows.push(row);
+        break;
+      }
+    }
+  }
+  const windows = [];
+  for (const row of [namedSession ?? fallbackSession, namedWeekly ?? fallbackWeekly, ...modelWindows]) {
+    if (row) windows.push(row);
+    if (windows.length === MAX_WINDOWS) break;
+  }
+  return { windows };
+}
+function codexWindow(source, fallbackId) {
+  const row = object(source);
+  if (!row) return null;
+  const seconds = typeof row.limit_window_seconds === "number" ? row.limit_window_seconds : 0;
+  const minutes = seconds / 60;
+  const id = minutes >= 240 && minutes <= 360 ? "session" : minutes >= 8064 && minutes <= 12096 ? "weekly" : fallbackId;
+  return {
+    id,
+    usedPercent: percent(row.used_percent),
+    ...safeTimestamp(row.reset_at) !== void 0 ? { resetsAt: safeTimestamp(row.reset_at) } : {}
+  };
+}
+function parseCodexUsage(payload) {
+  const root = object(payload) ?? {};
+  const rateLimit = object(root.rate_limit) ?? {};
+  return {
+    windows: [
+      codexWindow(rateLimit.primary_window, "session"),
+      codexWindow(rateLimit.secondary_window, "weekly")
+    ].filter((row) => row !== null),
+    plan: titleCase(root.plan_type)
+  };
+}
+function parseCursorUsage(payload) {
+  const root = object(payload);
+  const planUsage = object(root?.planUsage);
+  if (root?.enabled === false || !planUsage) return { status: "no_subscription" };
+  const resetsAt = safeTimestamp(root?.billingCycleEnd);
+  const windows = [];
+  for (const [value, label] of [
+    [planUsage.totalPercentUsed, void 0],
+    [planUsage.autoPercentUsed, "Auto"],
+    [planUsage.apiPercentUsed, "API"]
+  ]) {
+    if (typeof value !== "number" || !Number.isFinite(value)) continue;
+    windows.push({
+      id: "cycle",
+      ...label ? { label } : {},
+      usedPercent: percent(value),
+      ...resetsAt !== void 0 ? { resetsAt } : {}
+    });
+  }
+  if (windows.length === 0) return { status: "no_subscription" };
+  const cycleStart = safeTimestamp(root?.billingCycleStart);
+  const cycleEnd = safeTimestamp(root?.billingCycleEnd);
+  let cycleDays;
+  if (cycleStart !== void 0 && cycleEnd !== void 0 && cycleEnd > cycleStart) {
+    const days = Math.round((cycleEnd - cycleStart) / 864e5);
+    if (days >= 1 && days <= 400) cycleDays = days;
+  }
+  return {
+    status: "ok",
+    windows,
+    ...cycleDays !== void 0 ? { cycleDays } : {}
+  };
+}
+function parseResetCredits(payload) {
+  const root = object(payload);
+  if (!root || !Number.isSafeInteger(root.available_count) || root.available_count < 0) return void 0;
+  const credits = array(root.credits);
+  let nextExpiresAt;
+  for (let index = 0; index < credits.length && index < MAX_CREDIT_ENTRIES; index += 1) {
+    const credit = object(credits[index]);
+    if (credit?.status !== "available") continue;
+    const expiry = safeTimestamp(credit.expires_at);
+    if (expiry !== void 0 && (nextExpiresAt === void 0 || expiry < nextExpiresAt)) {
+      nextExpiresAt = expiry;
+    }
+  }
+  return {
+    available: root.available_count,
+    ...nextExpiresAt !== void 0 ? { nextExpiresAt } : {}
+  };
+}
+async function requestJson(fetchImpl, url, init) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
+  try {
+    const response = await fetchImpl(url, {
+      ...init,
+      signal: controller.signal,
+      redirect: "error"
+    });
+    if (response.url !== "" && response.url !== url) throw new ProviderHttpError();
+    if (!response.ok) throw new ProviderHttpError(response.status);
+    const contentLength = Number(response.headers.get("content-length"));
+    if (Number.isFinite(contentLength) && contentLength > MAX_RESPONSE_BYTES) {
+      controller.abort();
+      throw new ProviderResponseTooLargeError();
+    }
+    if (!response.body) {
+      const text = await response.text();
+      if (text.length > MAX_RESPONSE_BYTES) {
+        controller.abort();
+        throw new ProviderResponseTooLargeError();
+      }
+      return JSON.parse(text);
+    }
+    const reader = response.body.getReader();
+    const chunks = [];
+    let totalBytes = 0;
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      totalBytes += value.byteLength;
+      if (totalBytes > MAX_RESPONSE_BYTES) {
+        controller.abort();
+        throw new ProviderResponseTooLargeError();
+      }
+      chunks.push(value);
+    }
+    const body = new Uint8Array(totalBytes);
+    let offset = 0;
+    for (const chunk of chunks) {
+      body.set(chunk, offset);
+      offset += chunk.byteLength;
+    }
+    return JSON.parse(new TextDecoder().decode(body));
+  } finally {
+    clearTimeout(timer);
+  }
+}
+async function getJson(fetchImpl, url, headers) {
+  return requestJson(fetchImpl, url, { method: "GET", headers });
+}
+async function postJson(fetchImpl, url, headers) {
+  return requestJson(fetchImpl, url, { method: "POST", headers, body: "{}" });
+}
+function expired(error) {
+  return error instanceof ProviderHttpError && (error.statusCode === 401 || error.statusCode === 403) ? { status: "expired" } : null;
+}
+async function fetchClaudeUsage(deps = {}) {
+  const credentials = await resolveClaudeCredentials(deps.credentials ?? defaultCredentialDeps);
+  if (!credentials) return { status: "signed_out" };
+  if (credentials.expiresAt !== void 0 && credentials.expiresAt <= (deps.now ?? Date.now)()) {
+    return { status: "expired", method: credentials.method };
+  }
+  try {
+    const parsed = parseClaudeUsage(await getJson(
+      deps.fetch ?? fetch,
+      "https://api.anthropic.com/api/oauth/usage",
+      {
+        Authorization: `Bearer ${credentials.accessToken}`,
+        "anthropic-beta": "oauth-2025-04-20",
+        "User-Agent": "claude-code/2.1.0"
+      }
+    ));
+    return {
+      status: "ok",
+      method: credentials.method,
+      plan: titleCase(credentials.subscriptionType),
+      windows: parsed.windows,
+      fetchedAt: (deps.now ?? Date.now)()
+    };
+  } catch (error) {
+    const result = expired(error);
+    if (result) return { ...result, method: credentials.method };
+    throw error;
+  }
+}
+async function fetchCodexUsage(deps = {}) {
+  const credentials = await resolveCodexCredentials(deps.credentials ?? defaultCredentialDeps);
+  if (!credentials) return { status: "signed_out" };
+  const headers = {
+    Authorization: `Bearer ${credentials.accessToken}`,
+    "User-Agent": "codex-cli",
+    "OpenAI-Beta": "codex-1",
+    originator: "Codex Desktop"
+  };
+  if (credentials.accountId) headers["ChatGPT-Account-Id"] = credentials.accountId;
+  try {
+    const fetchImpl = deps.fetch ?? fetch;
+    const usage = parseCodexUsage(await getJson(fetchImpl, "https://chatgpt.com/backend-api/wham/usage", headers));
+    let credits;
+    try {
+      credits = parseResetCredits(await getJson(
+        fetchImpl,
+        "https://chatgpt.com/backend-api/wham/rate-limit-reset-credits",
+        headers
+      ));
+    } catch {
+      credits = void 0;
+    }
+    return {
+      status: "ok",
+      plan: usage.plan,
+      windows: usage.windows,
+      ...credits ? { credits } : {},
+      fetchedAt: (deps.now ?? Date.now)()
+    };
+  } catch (error) {
+    const result = expired(error);
+    if (result) return result;
+    throw error;
+  }
+}
+async function fetchCursorUsage(deps = {}) {
+  const credentials = await resolveCursorCredentials(deps.credentials ?? defaultCredentialDeps);
+  if (!credentials) return { status: "signed_out" };
+  const headers = {
+    Authorization: `Bearer ${credentials.accessToken}`,
+    "Content-Type": "application/json",
+    "Connect-Protocol-Version": "1"
+  };
+  try {
+    const fetchImpl = deps.fetch ?? fetch;
+    const usage = parseCursorUsage(await postJson(
+      fetchImpl,
+      "https://api2.cursor.sh/aiserver.v1.DashboardService/GetCurrentPeriodUsage",
+      headers
+    ));
+    if (usage.status === "no_subscription") return { status: "no_subscription", method: credentials.method };
+    let plan;
+    try {
+      const planRoot = object(await postJson(
+        fetchImpl,
+        "https://api2.cursor.sh/aiserver.v1.DashboardService/GetPlanInfo",
+        headers
+      ));
+      plan = titleCase(object(planRoot?.planInfo)?.planName ?? planRoot?.planName);
+    } catch {
+      plan = void 0;
+    }
+    return {
+      status: "ok",
+      method: credentials.method,
+      ...plan ? { plan } : {},
+      ...usage.cycleDays !== void 0 ? { cycleDays: usage.cycleDays } : {},
+      windows: usage.windows,
+      fetchedAt: (deps.now ?? Date.now)()
+    };
+  } catch (error) {
+    const result = expired(error);
+    if (result) return { ...result, method: credentials.method };
+    throw error;
+  }
+}
+function sanitizeProviderError(error) {
+  if (error instanceof ProviderResponseTooLargeError) return "Provider response too large";
+  if (error instanceof DOMException && error.name === "AbortError") return "Provider request timed out";
+  if (error instanceof ProviderHttpError && error.statusCode !== void 0) {
+    return `Provider request failed (${error.statusCode})`;
+  }
+  return "Provider request failed";
+}
+
+// ../fleet-plugins/quota/server/service.ts
+var CACHE_TTL_MS = 12e4;
+var STALE_TTL_MS = 18e5;
+function isProviderSuccess(value) {
+  return value.status === "ok" && Array.isArray(value.windows) && typeof value.fetchedAt === "number";
+}
+function createQuotaService(deps) {
+  const now = deps.now ?? Date.now;
+  const fetchers = {
+    claude: deps.fetchClaude ?? (() => fetchClaudeUsage()),
+    codex: deps.fetchCodex ?? (() => fetchCodexUsage()),
+    cursor: deps.fetchCursor ?? (() => fetchCursorUsage())
+  };
+  const cache = /* @__PURE__ */ new Map();
+  const lastGood = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Map();
+  async function load(id, force) {
+    if (id === "claude" && !await deps.isClaudeConnected() || id === "cursor" && !await deps.isCursorConnected()) {
+      return { status: "not_connected", method: (deps.platform ?? process.platform) === "darwin" ? "keychain" : "file" };
+    }
+    const cached = cache.get(id);
+    if (!force && cached && cached.expiresAt > now()) {
+      const staleStillValid = cached.value.status !== "stale" || typeof cached.value.fetchedAt === "number" && now() - cached.value.fetchedAt <= STALE_TTL_MS;
+      if (staleStillValid) return cached.value;
+      cache.delete(id);
+    }
+    const pending = inFlight.get(id);
+    if (pending) return pending;
+    const task = fetchers[id]().then((value) => {
+      if (isProviderSuccess(value)) lastGood.set(id, value);
+      cache.set(id, { value, expiresAt: now() + CACHE_TTL_MS });
+      return value;
+    }).catch((error) => {
+      const previous = lastGood.get(id);
+      const message = sanitizeProviderError(error);
+      const failedAt = now();
+      const value = previous && failedAt - previous.fetchedAt <= STALE_TTL_MS ? { ...previous, status: "stale", message } : { status: "error", message };
+      const expiresAt = value.status === "stale" && previous ? Math.min(failedAt + CACHE_TTL_MS, previous.fetchedAt + STALE_TTL_MS) : failedAt + CACHE_TTL_MS;
+      cache.set(id, { value, expiresAt });
+      return value;
+    }).finally(() => inFlight.delete(id));
+    inFlight.set(id, task);
+    return task;
+  }
+  return {
+    async getSummary(options = {}) {
+      const [claude, codex, cursor] = await Promise.all([
+        load("claude", options.force === true || options.forceProvider === "claude"),
+        load("codex", options.force === true || options.forceProvider === "codex"),
+        load("cursor", options.force === true || options.forceProvider === "cursor")
+      ]);
+      return { providers: { claude, codex, cursor } };
+    }
+  };
+}
+
+// ../fleet-plugins/quota/routes.ts
+var routes_default = definePlugin({
+  id: "quota",
+  register(ctx) {
+    let settingsMutation = Promise.resolve();
+    const serializeSettings = (operation) => {
+      const result = settingsMutation.then(operation, operation);
+      settingsMutation = result.then(() => void 0, () => void 0);
+      return result;
+    };
+    const isConnected = async (provider) => {
+      const value = await ctx.host.storage.readJson("quota", "settings");
+      return value !== null && typeof value === "object" && !Array.isArray(value) && value[`${provider}Connected`] === true;
+    };
+    const service = createQuotaService({
+      platform: process.platform,
+      isClaudeConnected: () => isConnected("claude"),
+      isCursorConnected: () => isConnected("cursor")
+    });
+    registerRouter(ctx, "summary", async ({ req, res }) => {
+      await handleSummary(req, res, ctx, service);
+      return true;
+    });
+    registerRouter(ctx, "connect", async ({ req, res }) => {
+      await handleConnect(req, res, ctx, service, serializeSettings);
+      return true;
+    });
+  }
+});
+
+export { routes_default as default };