@jeffusion/bungee-core 5.5.0 → 5.6.1

package/dist/plugins/chatgpt-oauth/control.js

@@ -535,6 +535,7 @@ class AccountControlError extends Error {
 var MAX_ACCOUNTS = 128;
 var MAX_TEXT = 512;
 var MAX_TOKEN = 32768;
+var MAX_AUTO_RESET_ATTEMPTS = 256;
 function text(value, max = MAX_TEXT) {
   if (typeof value !== "string" || value.length === 0 || value.length > max || value.trim() !== value) {
     throw new AccountControlError("invalid_input");
@@ -550,13 +551,21 @@ function copyIdentity(value) {
   return value === undefined ? undefined : { ...value };
 }
 function copyAccount(value) {
-  return { ...value, identity: copyIdentity(value.identity), refreshLock: value.refreshLock && { ...value.refreshLock } };
+  return {
+    ...value,
+    identity: copyIdentity(value.identity),
+    refreshLock: value.refreshLock && { ...value.refreshLock },
+    autoResetAttempts: value.autoResetAttempts?.map((item) => ({ ...item }))
+  };
+}
+function validAutoResetAttempts(value) {
+  return value === undefined || Array.isArray(value) && value.length <= MAX_AUTO_RESET_ATTEMPTS && value.every((item) => item && typeof item.creditId === "string" && item.creditId.length > 0 && item.creditId.length <= MAX_TEXT && !/[\u0000-\u001f\u007f]/.test(item.creditId) && typeof item.redeemRequestId === "string" && /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(item.redeemRequestId) && (item.expiresAt === undefined || Number.isFinite(item.expiresAt) && item.expiresAt >= 0) && typeof item.completed === "boolean");
 }
 function validStoredAccount(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     return false;
   const account = value;
-  return typeof account.id === "string" && account.id.length > 0 && account.id.length <= 128 && typeof account.label === "string" && account.label.length > 0 && account.label.length <= MAX_TEXT && ["active", "disabled", "reauth_required", "revoked"].includes(account.status) && Number.isSafeInteger(account.generation) && account.generation > 0 && (account.loginFence === undefined || Number.isSafeInteger(account.loginFence) && account.loginFence > 0) && (account.credentialValid === undefined || typeof account.credentialValid === "boolean") && Number.isFinite(account.createdAt) && Number.isFinite(account.updatedAt);
+  return typeof account.id === "string" && account.id.length > 0 && account.id.length <= 128 && typeof account.label === "string" && account.label.length > 0 && account.label.length <= MAX_TEXT && ["active", "disabled", "reauth_required", "revoked"].includes(account.status) && Number.isSafeInteger(account.generation) && account.generation > 0 && (account.loginFence === undefined || Number.isSafeInteger(account.loginFence) && account.loginFence > 0) && (account.credentialValid === undefined || typeof account.credentialValid === "boolean") && (account.autoResetCredits === undefined || typeof account.autoResetCredits === "boolean") && validAutoResetAttempts(account.autoResetAttempts) && Number.isFinite(account.createdAt) && Number.isFinite(account.updatedAt);
 }
 function decode(value) {
   if (value === undefined)
@@ -590,6 +599,7 @@ function statusReason(account) {
   return;
 }
 function accountListItem(account) {
+  const pending = account.autoResetAttempts?.find((item) => !item.completed);
   return {
     id: account.id,
     label: account.label,
@@ -597,7 +607,9 @@ function accountListItem(account) {
     available: account.status === "active" && account.credentialValid && Boolean(account.accessToken && account.refreshToken && Number.isFinite(account.expiresAt)),
     reason: statusReason(account),
     expiresAt: account.expiresAt,
-    identity: copyIdentity(account.identity)
+    identity: copyIdentity(account.identity),
+    autoResetCredits: account.autoResetCredits === true,
+    pendingAutoReset: pending && { ...pending }
   };
 }
 
@@ -789,6 +801,71 @@ class AccountStore {
       return copyAccount(account);
     });
   }
+  async setAutoResetCredits(id, enabled) {
+    if (typeof enabled !== "boolean")
+      throw new AccountControlError("invalid_input");
+    return this.mutate((aggregate) => {
+      const account = aggregate.accounts.find((item) => item.id === id);
+      if (!account)
+        throw new AccountControlError("not_found");
+      if (account.status === "revoked")
+        throw new AccountControlError("revoked");
+      account.autoResetCredits = enabled;
+      account.updatedAt = Date.now();
+      return copyAccount(account);
+    });
+  }
+  async claimAutoReset(id, credit, now) {
+    return this.mutate((aggregate) => {
+      const account = aggregate.accounts.find((item) => item.id === id);
+      if (!account || !accountListItem(account).available || account.autoResetCredits !== true)
+        return;
+      const attempts = account.autoResetAttempts ?? [];
+      if (attempts.some((item) => !item.completed || item.creditId === credit.id))
+        return;
+      account.autoResetAttempts = attempts.filter((item) => !item.completed || item.expiresAt === undefined || item.expiresAt > now);
+      if (account.autoResetAttempts.length >= MAX_AUTO_RESET_ATTEMPTS || credit.expiresAt === undefined || credit.expiresAt <= now)
+        return;
+      const attempt = { creditId: credit.id, redeemRequestId: randomUUID(), expiresAt: credit.expiresAt, completed: false };
+      account.autoResetAttempts.push(attempt);
+      account.updatedAt = Date.now();
+      return { ...attempt };
+    });
+  }
+  async recordResetAttempt(id, redeemRequestId, credit, now) {
+    await this.mutate((aggregate) => {
+      const account = aggregate.accounts.find((item) => item.id === id);
+      if (!account)
+        throw new AccountControlError("not_found");
+      const attempts = account.autoResetAttempts ?? [];
+      const pending = attempts.find((item) => !item.completed);
+      if (pending) {
+        if (pending.redeemRequestId !== redeemRequestId || pending.creditId !== credit.id)
+          throw new AccountControlError("version_conflict");
+        return;
+      }
+      account.autoResetAttempts = attempts.filter((item) => item.creditId !== credit.id && (item.expiresAt === undefined || item.expiresAt > now));
+      if (account.autoResetAttempts.length >= MAX_AUTO_RESET_ATTEMPTS)
+        throw new AccountControlError("invalid_input");
+      account.autoResetAttempts.push({ creditId: credit.id, redeemRequestId, expiresAt: credit.expiresAt, completed: false });
+      account.updatedAt = Date.now();
+    });
+  }
+  async finishAutoReset(id, redeemRequestId, cancel = false) {
+    await this.mutate((aggregate) => {
+      const account = aggregate.accounts.find((item) => item.id === id);
+      if (!account)
+        throw new AccountControlError("not_found");
+      if (cancel)
+        account.autoResetAttempts = account.autoResetAttempts?.filter((item) => item.redeemRequestId !== redeemRequestId);
+      else {
+        const attempt = account.autoResetAttempts?.find((item) => item.redeemRequestId === redeemRequestId);
+        if (attempt)
+          attempt.completed = true;
+      }
+      account.updatedAt = Date.now();
+    });
+  }
   async enable(id) {
     return this.mutate((aggregate) => {
       const account = aggregate.accounts.find((item) => item.id === id);
@@ -1602,6 +1679,9 @@ class UsageService {
   resetKey(redeemRequestId, creditId) {
     return `${redeemRequestId}\x00${creditId}`;
   }
+  restorePendingReset(accountRef, redeemRequestId, creditId) {
+    this.unknownReset.set(accountRef, this.resetKey(redeemRequestId, creditId));
+  }
   async runReset(accountRef, lease, key, body) {
     let outcome;
     let windowsReset = 0;
@@ -1628,7 +1708,7 @@ class UsageService {
     } catch {}
     return { outcome, windowsReset, ...usage === undefined ? {} : { usage } };
   }
-  async consume(accountRef, redeemRequestId, creditId, signal) {
+  async consume(accountRef, redeemRequestId, creditId, signal, options = {}) {
     const key = this.resetKey(redeemRequestId, creditId);
     const active = this.resets.get(accountRef);
     if (active !== undefined) {
@@ -1660,6 +1740,9 @@ class UsageService {
           if (current.resetCredits.availableCount <= 0 || selected?.status !== "available")
             throw new UsageError("credit_unavailable");
           lease = await this.deps.credential(accountRef, this.deps.hostSignal);
+          if (options.canConsume && !await options.canConsume(selected))
+            throw new UsageError("credit_unavailable");
+          await options.beforeConsume?.(selected);
         }
         this.invalidate(accountRef);
         resolveOperation(await this.runReset(accountRef, lease, key, { redeem_request_id: redeemRequestId, credit_id: creditId }));
@@ -1684,6 +1767,193 @@ class UsageService {
   }
 }
 
+// plugins/chatgpt-oauth/server/auto-reset.ts
+var AUTO_RESET_LEAD_MS = 30 * 60 * 1000;
+var AUTO_RESET_INTERVAL_MS = 5 * 60 * 1000;
+var MAX_TIMER_DELAY_MS = 2147483647;
+var defaultTimer = {
+  schedule: (callback, delay) => {
+    const timer = setTimeout(() => {
+      callback();
+    }, delay);
+    timer.unref?.();
+    return timer;
+  },
+  cancel: (handle) => clearTimeout(handle)
+};
+function isAutoResetDue(credit, now) {
+  return credit.status === "available" && typeof credit.expiresAt === "number" && Number.isFinite(credit.expiresAt) && credit.expiresAt > now && credit.expiresAt - now <= AUTO_RESET_LEAD_MS;
+}
+
+class AutoResetScheduler {
+  accounts;
+  usage;
+  signal;
+  now;
+  timer;
+  handle;
+  started = false;
+  disposed = false;
+  running;
+  plans = new Map;
+  accountRuns = new Map;
+  constructor(accounts, usage, signal, now = Date.now, timer = defaultTimer) {
+    this.accounts = accounts;
+    this.usage = usage;
+    this.signal = signal;
+    this.now = now;
+    this.timer = timer;
+  }
+  start() {
+    if (this.started || this.disposed || this.signal.aborted)
+      return;
+    this.started = true;
+    this.schedule(0);
+  }
+  schedule(delay) {
+    if (!this.started || this.disposed || this.signal.aborted)
+      return;
+    this.handle = this.timer.schedule(async () => {
+      try {
+        await this.runOnce();
+      } catch {} finally {
+        this.schedule(AUTO_RESET_INTERVAL_MS);
+      }
+    }, delay);
+  }
+  runOnce() {
+    if (this.disposed || this.signal.aborted)
+      return Promise.resolve();
+    if (!this.running)
+      this.running = this.scan().finally(() => {
+        this.running = undefined;
+      });
+    return this.running;
+  }
+  async scan() {
+    const accounts = await this.accounts.list();
+    const eligible = new Set(accounts.filter((account) => account.available && account.autoResetCredits && (!account.pendingAutoReset || this.accountRuns.has(account.id))).map((account) => account.id));
+    for (const id of this.plans.keys())
+      if (!eligible.has(id))
+        this.cancelPlan(id);
+    for (const account of accounts) {
+      if (this.disposed || this.signal.aborted)
+        return;
+      if (!eligible.has(account.id))
+        continue;
+      if (this.accountRuns.has(account.id))
+        continue;
+      try {
+        const snapshot = await this.usage.get(account.id, this.signal, { forceFresh: true });
+        if (this.disposed || this.signal.aborted)
+          return;
+        if (snapshot.resetCredits.state !== "fresh")
+          continue;
+        this.cancelPlan(account.id);
+        if ((snapshot.resetCredits.availableCount ?? 0) <= 0)
+          continue;
+        const credits = [...snapshot.resetCredits.credits ?? []].filter((credit) => credit.status === "available" && typeof credit.expiresAt === "number" && Number.isFinite(credit.expiresAt) && credit.expiresAt > this.now()).sort((a, b) => a.expiresAt - b.expiresAt);
+        const plan = { credits };
+        this.plans.set(account.id, plan);
+        await this.executePlan(account.id, plan);
+      } catch {}
+    }
+  }
+  cancelPlan(accountRef, expected) {
+    const plan = this.plans.get(accountRef);
+    if (expected && plan !== expected)
+      return;
+    if (plan?.handle !== undefined)
+      this.timer.cancel(plan.handle);
+    this.plans.delete(accountRef);
+  }
+  armPlan(accountRef, plan) {
+    if (this.disposed || this.signal.aborted || this.plans.get(accountRef) !== plan)
+      return;
+    if (plan.credits.length === 0) {
+      this.cancelPlan(accountRef);
+      return;
+    }
+    const dueAt = plan.credits[0].expiresAt - AUTO_RESET_LEAD_MS;
+    plan.handle = this.timer.schedule(() => this.executePlan(accountRef, plan), Math.min(MAX_TIMER_DELAY_MS, Math.max(0, dueAt - this.now())));
+  }
+  executePlan(accountRef, plan) {
+    const previous = this.accountRuns.get(accountRef) ?? Promise.resolve();
+    const operation = previous.catch(() => {
+      return;
+    }).then(async () => {
+      if (this.disposed || this.signal.aborted || this.plans.get(accountRef) !== plan)
+        return;
+      try {
+        const account = accountListItem(await this.accounts.get(accountRef));
+        if (!account.available || !account.autoResetCredits || account.pendingAutoReset) {
+          this.cancelPlan(accountRef, plan);
+          return;
+        }
+        while (this.plans.get(accountRef) === plan && plan.credits.length > 0) {
+          if (this.disposed || this.signal.aborted)
+            return;
+          const credit = plan.credits[0];
+          if (credit.expiresAt - AUTO_RESET_LEAD_MS > this.now())
+            break;
+          plan.credits.shift();
+          if (!isAutoResetDue(credit, this.now()))
+            continue;
+          const attempt = await this.accounts.claimAutoReset(accountRef, credit, this.now());
+          if (!attempt)
+            continue;
+          let deferred;
+          try {
+            const result = await this.usage.consume(accountRef, attempt.redeemRequestId, credit.id, this.signal, {
+              canConsume: async (selected) => {
+                const latest = await this.accounts.get(accountRef);
+                if (this.disposed || this.signal.aborted || latest.autoResetCredits !== true || latest.status !== "active")
+                  return false;
+                if (selected.status === "available" && typeof selected.expiresAt === "number" && Number.isFinite(selected.expiresAt) && selected.expiresAt - AUTO_RESET_LEAD_MS > this.now())
+                  deferred = selected;
+                return isAutoResetDue(selected, this.now());
+              }
+            });
+            if (result.outcome === "reset_outcome_unknown") {
+              this.cancelPlan(accountRef, plan);
+              return;
+            }
+            await this.accounts.finishAutoReset(accountRef, attempt.redeemRequestId);
+          } catch (error) {
+            if (error instanceof UsageError && ["credits_unavailable", "credit_unavailable", "reset_in_progress"].includes(error.code)) {
+              await this.accounts.finishAutoReset(accountRef, attempt.redeemRequestId, true);
+              if (error.code === "credit_unavailable") {
+                if (deferred) {
+                  plan.credits.push(deferred);
+                  plan.credits.sort((a, b) => a.expiresAt - b.expiresAt);
+                }
+                continue;
+              }
+            }
+            this.cancelPlan(accountRef, plan);
+            return;
+          }
+        }
+        this.armPlan(accountRef, plan);
+      } catch {
+        this.cancelPlan(accountRef, plan);
+      }
+    }).finally(() => {
+      if (this.accountRuns.get(accountRef) === operation)
+        this.accountRuns.delete(accountRef);
+    });
+    this.accountRuns.set(accountRef, operation);
+    return operation;
+  }
+  dispose() {
+    this.started = false;
+    this.disposed = true;
+    this.timer.cancel(this.handle);
+    for (const id of this.plans.keys())
+      this.cancelPlan(id);
+  }
+}
+
 // plugins/chatgpt-oauth/server/control.ts
 var CHATGPT_TARGET = "https://chatgpt.com";
 var CONTROL_HOST_CONTRACT_GAP = "ControlRpcContext.binding.bindingOptions.accountRef is required and host-resolved; RPC payload is never used as a fallback.";
@@ -1900,6 +2170,7 @@ class ChatgptControl {
   refreshControllers = new Map;
   apiLifetime = new AbortController;
   usage;
+  autoReset;
   disposed = false;
   abortListener;
   constructor(host, deps = {}) {
@@ -1912,10 +2183,11 @@ class ChatgptControl {
       fetchImpl: deps.fetchImpl,
       now: this.now,
       timeoutMs: deps.timeoutMs,
-      hostSignal: host.signal,
+      hostSignal: this.apiLifetime.signal,
       credential: (id, signal) => this.credential(id, signal),
       rejectAccess: (id, version) => this.accounts.rejectAccess(id, version)
     });
+    this.autoReset = new AutoResetScheduler(this.accounts, this.usage, this.apiLifetime.signal, this.now, deps.autoResetTimer);
     this.abortListener = () => {
       this.dispose();
     };
@@ -1936,6 +2208,7 @@ class ChatgptControl {
     this.assertAlive();
     await this.accounts.read();
     this.assertAlive();
+    this.autoReset.start();
   }
   async refresh(id, signal) {
     for (let attempt = 0;attempt < 120; attempt++) {
@@ -2080,7 +2353,25 @@ class ChatgptControl {
         const creditId = requiredText(body.creditId, 512);
         if (/[\0\r\n]/.test(creditId))
           throw new ControlError("invalid_input");
-        return jsonResponse(await this.usage.consume(accountRef, redeemRequestId, creditId, context.requestSignal));
+        const pending = accountListItem(await this.accounts.get(accountRef)).pendingAutoReset;
+        if (pending) {
+          if (pending.redeemRequestId !== redeemRequestId || pending.creditId !== creditId)
+            throw new ControlError("reset_in_progress");
+          this.usage.restorePendingReset(accountRef, redeemRequestId, creditId);
+        }
+        const result = await this.usage.consume(accountRef, redeemRequestId, creditId, context.requestSignal, {
+          beforeConsume: (selected) => this.accounts.recordResetAttempt(accountRef, redeemRequestId, selected, this.now())
+        });
+        if (result.outcome !== "reset_outcome_unknown")
+          await this.accounts.finishAutoReset(accountRef, redeemRequestId);
+        return jsonResponse(result);
+      }) },
+      { path: "/accounts/auto-reset", methods: ["POST"], handler: "setAutoResetCredits", invoke: invoke(async (context) => {
+        const body = await this.readJson(context);
+        exactKeys(body, ["accountRef", "enabled"]);
+        if (typeof body.enabled !== "boolean")
+          throw new ControlError("invalid_input");
+        return jsonResponse({ account: accountListItem(await this.accounts.setAutoResetCredits(requiredText(body.accountRef, 128), body.enabled)) });
       }) },
       { path: "/accounts/draft", methods: ["POST"], handler: "createDraft", invoke: invoke(async (context) => {
         const body = await this.readJson(context);
@@ -2203,6 +2494,7 @@ class ChatgptControl {
     for (const controller of this.refreshControllers.values())
       controller.abort("disposed");
     this.sessions.dispose();
+    this.autoReset.dispose();
     this.usage.dispose();
     this.inFlight.clear();
   }
@@ -2214,6 +2506,7 @@ var api = Object.freeze([
   { path: "/accounts", methods: ["GET"], handler: "listAccounts" },
   { path: "/accounts/usage", methods: ["GET"], handler: "getAccountUsage" },
   { path: "/accounts/usage/reset", methods: ["POST"], handler: "resetAccountUsage" },
+  { path: "/accounts/auto-reset", methods: ["POST"], handler: "setAutoResetCredits" },
   { path: "/accounts/draft", methods: ["POST"], handler: "createDraft" },
   { path: "/login/device", methods: ["POST"], handler: "startDeviceLogin" },
   { path: "/login/pkce", methods: ["POST"], handler: "startPkceLogin" },
@@ -2242,4 +2535,4 @@ export {
   rpc
 };
 
-//# debugId=972BABF0927EC93164756E2164756E21
+//# debugId=8E7B0629542A407F64756E2164756E21