opencode-skills-collection 3.0.34 → 3.0.36

package/bundled-skills/vercel-optimize/lib/throttle.mjs

@@ -0,0 +1,273 @@
+// Zero-dependency concurrency + rate-limit primitives for `vercel metrics`. API cap is 100 req / 60s / team.
+// CLI fails fast on 429 and doesn't surface Retry-After, so we back off blind.
+
+const DEFAULT_CONCURRENCY = 8;
+const DEFAULT_MAX_RETRIES = 3;
+// Wait most of a 60s window when rate-limited — we don't know how much headroom remains. Jitter prevents lockstep retry.
+const BASE_BACKOFF_MS = 60_000;
+const JITTER_MS = 15_000;
+// 20% headroom under the 100/60s cap for the user's other concurrent CLI usage.
+const DEFAULT_RATE_LIMIT = 80;
+const DEFAULT_RATE_WINDOW_MS = 60_000;
+const DAILY_OBSERVABILITY_LIMIT_RE = /daily.*observability.*query limit/i;
+
+let dailyQuotaBlock = null;
+
+export function resolveConcurrency() {
+  return parsePositiveIntEnv('VERCEL_OPTIMIZE_METRIC_CONCURRENCY', DEFAULT_CONCURRENCY);
+}
+
+// Format: VERCEL_OPTIMIZE_METRIC_RATE=N or N/60s.
+export function resolveRateLimit() {
+  const env = process.env.VERCEL_OPTIMIZE_METRIC_RATE;
+  if (env == null || env === '') return { maxCalls: DEFAULT_RATE_LIMIT, windowMs: DEFAULT_RATE_WINDOW_MS };
+  const m = String(env).trim().match(/^(\d+)(?:\/(\d+)([sm])?)?$/);
+  if (!m) return { maxCalls: DEFAULT_RATE_LIMIT, windowMs: DEFAULT_RATE_WINDOW_MS };
+  const maxCalls = Number(m[1]);
+  if (!Number.isInteger(maxCalls) || maxCalls < 1) {
+    return { maxCalls: DEFAULT_RATE_LIMIT, windowMs: DEFAULT_RATE_WINDOW_MS };
+  }
+  if (!m[2]) return { maxCalls, windowMs: DEFAULT_RATE_WINDOW_MS };
+  const unit = m[3] === 'm' ? 60_000 : 1_000;
+  const windowMs = Number(m[2]) * unit;
+  return { maxCalls, windowMs };
+}
+
+function parsePositiveIntEnv(name, defaultValue) {
+  const env = process.env[name];
+  if (env == null || env === '') return defaultValue;
+  const n = Number(env);
+  if (!Number.isFinite(n) || n < 1 || !Number.isInteger(n)) return defaultValue;
+  return n;
+}
+
+// FIFO semaphore. Caller MUST call returned release() exactly once.
+export class SemaphoreAbortError extends Error {
+  constructor(result) {
+    super('Semaphore acquire aborted');
+    this.name = 'SemaphoreAbortError';
+    this.result = result;
+  }
+}
+
+export class Semaphore {
+  constructor(max) {
+    if (!Number.isInteger(max) || max < 1) {
+      throw new Error(`Semaphore: max must be a positive integer (got ${max})`);
+    }
+    this.max = max;
+    this.inFlight = 0;
+    this.waiters = [];
+  }
+
+  async acquire(opts = {}) {
+    const abortIf = opts.abortIf;
+    const preAbort = abortIf?.();
+    if (preAbort) throw new SemaphoreAbortError(preAbort);
+    if (this.inFlight < this.max) {
+      this.inFlight++;
+      return () => this.release();
+    }
+    await new Promise((resolve) => this.waiters.push(resolve));
+    const postAbort = abortIf?.();
+    if (postAbort) {
+      this.wakeNext();
+      throw new SemaphoreAbortError(postAbort);
+    }
+    this.inFlight++;
+    return () => this.release();
+  }
+
+  release() {
+    this.inFlight--;
+    this.wakeNext();
+  }
+
+  wakeNext() {
+    const next = this.waiters.shift();
+    if (next) next();
+  }
+
+  async run(fn, opts = {}) {
+    const release = await this.acquire(opts);
+    try {
+      return await fn();
+    } finally {
+      release();
+    }
+  }
+}
+
+// Load-bearing — semaphore alone is insufficient (8 concurrent × ~1s queries = 480/min, well above the 100/min cap).
+export class SlidingWindowRateLimiter {
+  constructor(maxCalls, windowMs, opts = {}) {
+    if (!Number.isInteger(maxCalls) || maxCalls < 1) {
+      throw new Error(`SlidingWindowRateLimiter: maxCalls must be >=1 (got ${maxCalls})`);
+    }
+    if (!Number.isFinite(windowMs) || windowMs < 1) {
+      throw new Error(`SlidingWindowRateLimiter: windowMs must be >0 (got ${windowMs})`);
+    }
+    this.maxCalls = maxCalls;
+    this.windowMs = windowMs;
+    this.timestamps = []; // ascending order
+    this.now = opts.now ?? (() => Date.now());
+    this.sleep = opts.sleep ?? defaultSleep;
+  }
+
+  async acquire() {
+    while (true) {
+      this.prune();
+      if (this.timestamps.length < this.maxCalls) {
+        this.timestamps.push(this.now());
+        return;
+      }
+      // Small buffer avoids racing the window boundary.
+      const oldestExpiresAt = this.timestamps[0] + this.windowMs;
+      const sleepMs = Math.max(50, oldestExpiresAt - this.now() + 100);
+      await this.sleep(sleepMs);
+    }
+  }
+
+  prune() {
+    const cutoff = this.now() - this.windowMs;
+    while (this.timestamps.length > 0 && this.timestamps[0] < cutoff) {
+      this.timestamps.shift();
+    }
+  }
+}
+
+// Composes Semaphore + RateLimiter: bounds both burst (8 concurrent) and sustained throughput (80/60s).
+let metricThrottleSingleton = null;
+export function getMetricThrottle() {
+  if (!metricThrottleSingleton) {
+    const semaphore = new Semaphore(resolveConcurrency());
+    const { maxCalls, windowMs } = resolveRateLimit();
+    const rateLimiter = new SlidingWindowRateLimiter(maxCalls, windowMs);
+    metricThrottleSingleton = {
+      semaphore,
+      rateLimiter,
+      maxCalls,
+      windowMs,
+      async run(fn) {
+        const cached = getDailyQuotaBlock();
+        if (cached) return dailyQuotaResult(cached);
+        let release;
+        try {
+          release = await semaphore.acquire({ abortIf: () => {
+            const block = getDailyQuotaBlock();
+            return block ? dailyQuotaResult(block) : null;
+          } });
+        } catch (err) {
+          if (err instanceof SemaphoreAbortError) return err.result;
+          throw err;
+        }
+        try {
+          const afterAcquire = getDailyQuotaBlock();
+          if (afterAcquire) return dailyQuotaResult(afterAcquire);
+          await rateLimiter.acquire();
+          const result = await fn();
+          if (isDailyQuotaExceeded(result)) {
+            const block = setDailyQuotaBlocked(result);
+            return dailyQuotaResult(block, result);
+          }
+          return result;
+        } finally {
+          release();
+        }
+      },
+    };
+  }
+  return metricThrottleSingleton;
+}
+
+// Back-compat alias — returns the throttle object (compatible `.run(fn)` shape).
+export const getMetricSemaphore = getMetricThrottle;
+
+export function _resetMetricSemaphoreForTests() {
+  metricThrottleSingleton = null;
+  dailyQuotaBlock = null;
+}
+
+export async function retryOnRateLimit(fn, opts = {}) {
+  const maxRetries = opts.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const baseBackoffMs = opts.baseBackoffMs ?? BASE_BACKOFF_MS;
+  const jitterMs = opts.jitterMs ?? JITTER_MS;
+  const sleep = opts.sleep ?? defaultSleep;
+  const onRetry = opts.onRetry;
+
+  let attempt = 0;
+  while (true) {
+    const result = await fn();
+    if (!isRateLimited(result) || attempt >= maxRetries) return result;
+    attempt++;
+    // attempt 1 = 1x, 2 = 1.5x, 3 = 2x of base.
+    const factor = 1 + (attempt - 1) * 0.5;
+    const jitter = jitterMs > 0 ? Math.random() * jitterMs : 0;
+    const delay = Math.round(baseBackoffMs * factor + jitter);
+    if (onRetry) onRetry(attempt, delay, result);
+    await sleep(delay);
+  }
+}
+
+// Variants: code='RATE_LIMITED' (canonical), 'rate_limited', or 'EXIT_1' + stderr match.
+export function isRateLimited(result) {
+  if (!result || result.ok !== false) return false;
+  const code = String(result.code ?? '').toLowerCase();
+  if (code === 'rate_limited' || code === '429') return true;
+  const stderr = String(result.stderr ?? '').toLowerCase();
+  if (stderr.includes('rate limit') || stderr.includes('rate_limited') || stderr.includes('too many requests')) {
+    return true;
+  }
+  return false;
+}
+
+export function isDailyQuotaExceeded(result) {
+  if (!result || result.ok !== false) return false;
+  const code = String(result.code ?? '');
+  if (code.toUpperCase() === 'DAILY_QUOTA_EXCEEDED') return true;
+  const haystack = [
+    result.message,
+    result.stderr,
+    result.stdout,
+    result.detail,
+  ].filter(Boolean).join('\n');
+  return DAILY_OBSERVABILITY_LIMIT_RE.test(haystack);
+}
+
+export function setDailyQuotaBlocked(result, nowMs = Date.now()) {
+  dailyQuotaBlock = {
+    untilMs: utcMidnightAfter(nowMs),
+    originalCode: result?.code ?? null,
+    message: result?.message || result?.stderr || 'Daily Observability query limit reached.',
+  };
+  return dailyQuotaBlock;
+}
+
+export function getDailyQuotaBlock(nowMs = Date.now()) {
+  if (!dailyQuotaBlock) return null;
+  if (dailyQuotaBlock.untilMs <= nowMs) {
+    dailyQuotaBlock = null;
+    return null;
+  }
+  return dailyQuotaBlock;
+}
+
+export function utcMidnightAfter(nowMs) {
+  const d = new Date(nowMs);
+  return Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate() + 1);
+}
+
+function dailyQuotaResult(block, sourceResult = null) {
+  return {
+    ...(sourceResult && typeof sourceResult === 'object' ? sourceResult : {}),
+    ok: false,
+    code: 'DAILY_QUOTA_EXCEEDED',
+    message: block.message,
+    cachedUntil: new Date(block.untilMs).toISOString(),
+    originalCode: sourceResult?.originalCode ?? sourceResult?.code ?? block.originalCode ?? undefined,
+  };
+}
+
+function defaultSleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/bundled-skills/vercel-optimize/lib/util.mjs

@@ -0,0 +1,17 @@
+// Shared scanner + sanitizer helpers. Keep tiny — add only when duplicated 3+ times.
+
+// 1-based line number of `idx` in a multi-line string.
+export function lineOf(text, idx) {
+  return text.slice(0, idx).split('\n').length;
+}
+
+export function escapeRegex(s) {
+  return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+// `slow_route:/api/products` → `/api/products`.
+export function extractRoute(rec) {
+  if (typeof rec?.candidateRef !== 'string') return null;
+  const m = rec.candidateRef.match(/^[^:]+:(.+)$/);
+  return m ? m[1] : null;
+}