@goodandready/dsh-subscriptions 0.2.11 → 0.3.1

package/lib/accounts.js

@@ -48,12 +48,14 @@ export function vendorConfig(provider, cfg) {
   }
 }
 
-export function createAccountStore({ credentials, getConfig, fetchImpl }) {
+export function createAccountStore({ credentials, getConfig, fetchImpl, onLimitNotice }) {
   const cooldowns = new Map()
   const quotas = new Map()
   const refreshLocks = new Map()
   const refreshFailures = new Map()
   const usage = new Map()
+  const notifyThresholds = new Map()
+  const requestCounts = new Map()
   const windows = new Map()
   const usageFetched = new Map()
   const doFetch = fetchImpl || fetch
@@ -85,6 +87,8 @@ export function createAccountStore({ credentials, getConfig, fetchImpl }) {
     await credentials.unset(credentialRef(ref))
     cooldowns.delete(ref)
     quotas.delete(ref)
+    for (const k of [...notifyThresholds.keys()]) { if (k.startsWith(ref + ':')) notifyThresholds.delete(k) }
+    for (const k of [...notifyThresholds.keys()]) { if (k.startsWith(ref + ':')) notifyThresholds.delete(k) }
     refreshFailures.delete(ref)
     usage.delete(ref)
     usageFetched.delete(ref)
@@ -201,6 +205,40 @@ export function createAccountStore({ credentials, getConfig, fetchImpl }) {
         if (Number.isFinite(Number(snap.usedPercent))) {
           usage.set(slot.ref, Number(snap.usedPercent))
         }
+        // Notification thresholds: 70/90/100% — fire once per window until reset.
+        if (Array.isArray(snap.windows)) {
+          for (const win of snap.windows) {
+            if (!win || !Number.isFinite(Number(win.usedPercent))) continue
+            const pct = Number(win.usedPercent)
+            const key = slot.ref + ':' + win.id
+            const prev = notifyThresholds.get(key) || 0
+            const THRESHOLDS = [70, 90, 100]
+            for (const th of THRESHOLDS) {
+              if (pct >= th && prev < th) {
+                notifyThresholds.set(key, th)
+                try { onLimitNotice && onLimitNotice(slot.provider, slot.ref, win, th) } catch {}
+                break
+              }
+            }
+          }
+        }
+        // Notification thresholds: 70/90/100% — fire once per window until reset.
+        if (Array.isArray(snap.windows)) {
+          for (const win of snap.windows) {
+            if (!win || !Number.isFinite(Number(win.usedPercent))) continue
+            const pct = Number(win.usedPercent)
+            const key = slot.ref + ':' + win.id
+            const prev = notifyThresholds.get(key) || 0
+            const THRESHOLDS = [70, 90, 100]
+            for (const th of THRESHOLDS) {
+              if (pct >= th && prev < th) {
+                notifyThresholds.set(key, th)
+                try { onLimitNotice && onLimitNotice(slot.provider, slot.ref, win, th) } catch {}
+                break
+              }
+            }
+          }
+        }
         const list = Array.isArray(snap.windows) ? snap.windows : null
         if (list) {
           windows.set(slot.ref, list)
@@ -235,5 +273,7 @@ export function createAccountStore({ credentials, getConfig, fetchImpl }) {
     shouldSkipRefresh(ref, now, retryMs) { const f = refreshFailures.get(ref); if (!f) return false; return (Number(f.at) + Number(retryMs)) > Number(now) },
     getQuota(ref) { return quotas.get(ref) || null },
     rememberUsage(ref, percent) { usage.set(ref, percent) },
+    rememberRequest(ref) { requestCounts.set(ref, (requestCounts.get(ref) || 0) + 1) },
+    getRequestCount(ref) { return requestCounts.get(ref) || 0 },
   }
 }

package/lib/adapter.js

@@ -106,6 +106,7 @@ export class SubscriptionAdapter extends LlmAdapter {
             return res
           }
           try {
+            if (typeof deps.rememberRequest === 'function') deps.rememberRequest(account.ref)
             yield* vendor.streamOnce({
               blob,
               options: opts,

package/lib/client.js

@@ -37,7 +37,12 @@ window.__ModuleLoader__.load({
     '.dsub-badge-on{color:var(--dsw-alias-state-success-primary);border-color:currentColor}' +
     '.dsub-badge-warn{color:var(--dsw-alias-state-warning-primary);border-color:currentColor}' +
     '.dsub-link{background:none;border:none;color:var(--dsw-alias-label-secondary);cursor:pointer;font-size:12px;padding:0}' +
-    '.dsub-verify{font-size:12px;color:var(--dsw-alias-state-warning-primary)}' +
+    '.dsub-bar{position:relative;height:6px;border-radius:3px;background:var(--dsw-alias-bg-layer-1);overflow:hidden;flex:1;min-width:80px}' +
+    '.dsub-barFill{height:100%;border-radius:3px;background:var(--dsw-alias-state-success-primary);transition:width .2s}' +
+    '.dsub-barWarn .dsub-barFill{background:var(--dsw-alias-state-warning-primary)}' +
+    '.dsub-barFull .dsub-barFill{background:var(--dsw-alias-state-error-primary)}' +
+    '.dsub-barRow{display:flex;align-items:center;gap:8px;font-size:12px;color:var(--dsw-alias-label-secondary)}' +
+    '.dsub-verify{font-size:12px;color:var(--dsw-alias-state-warning-primary)}' + +
     '.dsub-verify a{color:var(--dsw-alias-brand-primary)}'
 
 const cssId = 'dsh-subscriptions/settings.module.css'
@@ -82,6 +87,9 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       'accountLabel': 'Account',
       'plan': 'Plan',
       'storedAs': 'Stored as',
+      'switchLabel': 'Provider',
+      'none': 'none',
+      'forecast': '≈',
     }
     const ru = {
       'notConnected': 'Не подключено',
@@ -112,6 +120,9 @@ const cssId = 'dsh-subscriptions/settings.module.css'
       'accountLabel': 'Аккаунт',
       'plan': 'Тариф',
       'storedAs': 'Хранится как',
+      'switchLabel': 'Провайдер',
+      'none': 'нет',
+      'forecast': '≈',
     }
 
     function badgeFor(account, t) {
@@ -358,25 +369,36 @@ function PluginCard(props) {
 (function(){
                   var parts=[]
                   var wins=account.usage
+                  function bar(label,pct){
+                    var cls='dsub-bar'+(pct>=100?' dsub-barFull':(pct>=70?' dsub-barWarn':''))
+                    return React.createElement('div',{className:'dsub-barRow',key:label},
+                      React.createElement('span',null,label),
+                      React.createElement('div',{className:cls},
+                        React.createElement('div',{className:'dsub-barFill',style:{width:Math.min(100,Math.max(0,pct))+'%'}})
+                      ),
+                      React.createElement('span',null,Math.round(pct)+'%'),
+                    )
+                  }
                   if(Array.isArray(wins)&&wins.length){
                     wins.forEach(function(w){
-                      if(w&&w.usedPercent!=null)parts.push(t('limit')+' '+(w.ru||w.id)+': '+Math.round(w.usedPercent)+'/100%')
+                      if(w&&w.usedPercent!=null)parts.push(bar((w.ru||w.id),w.usedPercent))
                     })
                   }
                   var q=account.quota
-                  if(q){
-                    var qa=[]
-                    if(q.remaining!=null&&q.limit!=null)qa.push(q.remaining+'/'+q.limit)
-                    else if(q.remaining!=null)qa.push(String(q.remaining))
-                    if(q.usedPercent!=null)qa.push(Math.round(q.usedPercent)+'%')
-                    if(q.resetAt){var d=new Date(q.resetAt);qa.push(d.toLocaleTimeString())}
-                    if(qa.length)parts.push(t('quota')+': '+qa.join(' / '))
-                  }
-                  if(!wins&&!q&&account.usagePercent!=null)parts.push(Math.round(account.usagePercent)+'/100%')
+                  if(q&&q.usedPercent!=null)parts.push(bar(t('quota'),q.usedPercent))
+                  if(!wins&&!q&&account.usagePercent!=null)parts.push(bar(t('quota'),account.usagePercent))
                   var at=(q&&q.measuredAt)||(account.usageAt||0)
-                  if(at){var m=Math.round((Date.now()-at)/60000);if(m>=1)parts.push(m+'m')}
+                  if(at){var m=Math.round((Date.now()-at)/60000);if(m>=1)parts.push(React.createElement('span',{className:'dsub-sub',key:'ago'},m+'m'))}
+                  if(Array.isArray(wins)&&wins.length&&account.requests){
+                    var w0=wins[0]
+                    if(w0&&w0.usedPercent!=null&&w0.usedPercent<100){
+                      var remaining=100-w0.usedPercent
+                      var est=Math.floor(remaining/(w0.usedPercent/account.requests))
+                      if(est>0)parts.push(React.createElement('span',{className:'dsub-sub',key:'fc'},t('forecast')+' '+est+' ('+(w0.ru||w0.id)+')'))
+                    }
+                  }
                   if(!parts.length)return null
-                  return React.createElement('span',{className:'dsub-sub'},parts.join(' \u00b7 '))
+                  return React.createElement('div',{className:'dsub-block'},parts)
                 })(),
 
                                 account.paidTierName ? React.createElement('span', { className: 'dsub-sub' }, t('plan') + ': ' + account.paidTierName) : null,
@@ -488,9 +510,69 @@ function PluginCard(props) {
       ))
     }
 
+    // Горячий переключатель провайдера в строке композера: клик циклично
+    // меняет активного провайдера подписки для следующего запроса.
+    let activeIdx = 0
+    let labelEl = null
+    const ORDER = ['codex', 'claude', 'grok', 'antigravity']
+
+    async function refreshLoggedIn() {
+      try {
+        const res = await fetch('/dsh-subscriptions/status', { cache: 'no-store' })
+        const data = await res.json().catch(() => ({}))
+        const loggedIn = (data && data.loggedIn) || {}
+        return ORDER.filter((p) => loggedIn[p])
+      } catch { return [] }
+    }
+
+    function registerComposerSwitch(ctx) {
+      ctx.effect(() => {
+        const render = () => {
+          if (!labelEl) return
+          refreshLoggedIn().then((logged) => {
+            if (!labelEl) return
+            const current = logged.length ? logged[activeIdx % logged.length] : null
+            labelEl.textContent = t('switchLabel') + ': ' + (current || t('none'))
+          }).catch(() => {})
+        }
+        ctx.slots.inject('composer.action', () =>
+          ctx.slots.register(
+            {
+              name: 'composer.action',
+              id: 'dsh-subscriptions-provider-switch',
+              order: 31,
+              label: () => {
+                // label используется ядром до монтирования; держим актуальным
+                setTimeout(render, 0)
+                return t('switchLabel')
+              },
+            },
+            (props) => {
+              const el = React.createElement('button', {
+                onClick: async () => {
+                  const logged = await refreshLoggedIn()
+                  if (!logged.length) return
+                  activeIdx = (activeIdx + 1) % logged.length
+                  render()
+                },
+              }, '')
+              // Обновить текст в смонтированном элементе
+              setTimeout(() => {
+                labelEl = el
+                render()
+              }, 0)
+              return el
+            },
+          ),
+        )
+        render()
+      }, 'dsh-subscriptions: composer provider switch')
+    }
+
     exports.inject = ['slots', 'locale']
     exports.apply = function apply(ctx) {
       registerSettings(ctx)
+      registerComposerSwitch(ctx)
     }
     return module.exports
   },

package/lib/crypto.js

@@ -0,0 +1,28 @@
+import { scryptSync, createCipheriv, createDecipheriv, randomBytes } from "node:crypto"
+
+// AES-256-GCM с ключом из passphrase (scrypt, без хранения соли отдельно —
+// соль в начале блока).
+export function encryptWithPassphrase(plainText, passphrase) {
+  const salt = randomBytes(16)
+  const key = scryptSync(String(passphrase), salt, 32)
+  const iv = randomBytes(12)
+  const cipher = createCipheriv("aes-256-gcm", key, iv)
+  const encrypted = Buffer.concat([cipher.update(String(plainText), "utf8"), cipher.final()])
+  const tag = cipher.getAuthTag()
+  // формат: magic + salt + iv + tag + data
+  return "DSHE1:" + Buffer.concat([salt, iv, tag, encrypted]).toString("base64")
+}
+
+export function decryptWithPassphrase(payload, passphrase) {
+  const raw = String(payload || "")
+  if (!raw.startsWith("DSHE1:")) throw new Error("неизвестный формат экспорта")
+  const buf = Buffer.from(raw.slice(6), "base64")
+  const salt = buf.subarray(0, 16)
+  const iv = buf.subarray(16, 28)
+  const tag = buf.subarray(28, 44)
+  const data = buf.subarray(44)
+  const key = scryptSync(String(passphrase), salt, 32)
+  const decipher = createDecipheriv("aes-256-gcm", key, iv)
+  decipher.setAuthTag(tag)
+  return Buffer.concat([decipher.update(data), decipher.final()]).toString("utf8")
+}

package/lib/index.js

@@ -8,6 +8,7 @@ import { SubscriptionAdapter } from './adapter.js'
 import { generateOnce, SIZES as IMAGE_SIZES } from './images.js'
 import { parseBlob } from './blob.js'
 import { createSubscriptionsService } from './subscriptions.js'
+import { encryptWithPassphrase, decryptWithPassphrase } from './crypto.js'
 import { quotaSnapshot } from './ratelimit.js'
 import { createAccountStore, normalizeSlots, vendorConfig } from './accounts.js'
 import {
@@ -36,12 +37,16 @@ const defaultSlots = PROVIDERS.map((provider) => ({ provider, index: 1, label: '
 export const Config = z.object({
   cooldownMs: z.number().default(30 * 60 * 1000)
     .description('After RATE_LIMIT/QUOTA/429, skip that account for this many milliseconds.'),
-  switchAtRemaining: z.number().default(0)
+  switchAtRemaining: z.number().default(0.01)
     .description('If remaining <= this (absolute or <1 fraction), treat as exhausted before request. 0 disables.'),
   refreshAheadMs: z.number().default(5 * 60 * 1000)
     .description('Background refresh when expiry within this many ms.'),
   refreshRetryMs: z.number().default(10 * 60 * 1000)
     .description('Do not retry background refresh more often than this after failure.'),
+  probeIntervalMin: z.number().default(15)
+    .description('Background health-check interval in minutes. 0 disables.'),
+  notifyLimits: z.boolean().default(true)
+    .description('Emit log notices when usage crosses 70/90/100% of a window.'),
   slots: z.array(Slot).default(defaultSlots)
     .description('Account slots. Secrets are not stored here; only the credential ref names.'),
   useWebCallback: z.boolean().default(false)
@@ -86,7 +91,17 @@ export function apply(ctx, config) {
   })
 
   const live = () => Config(structuredClone(getConfig() ?? {})) ?? config
-  const store = createAccountStore({ credentials: ctx.credentials, getConfig: live, fetchImpl: fetch })
+  const store = createAccountStore({
+    credentials: ctx.credentials,
+    getConfig: live,
+    fetchImpl: fetch,
+    onLimitNotice: (provider, ref, win, threshold) => {
+      if (!live().notifyLimits) return
+      const label = win.ru || win.en || win.id
+      try { ctx.log && ctx.log.warn && ctx.log.warn(`[dsh-subscriptions] ${provider} ${ref}: лимит ${label} на ${threshold}%`) } catch {}
+      try { ctx.emit && ctx.emit('subscriptions.limit-notice', { provider, ref, window: win.id, usedPercent: win.usedPercent, threshold }) } catch {}
+    },
+  })
   const subscriptions = createSubscriptionsService({
     listAccounts: (provider) => store.listAccounts(provider),
     loadBlob: (ref) => store.loadBlob(ref),
@@ -96,6 +111,8 @@ export function apply(ctx, config) {
     switchAtRemaining: () => live().switchAtRemaining,
     rememberCooldown: (ref, until) => store.rememberCooldown(ref, until),
     rememberQuota: (ref, snap) => store.rememberQuota(ref, snap),
+    rememberRequest: (ref) => store.rememberRequest(ref),
+    getRequestCount: (ref) => store.getRequestCount(ref),
     fetchImpl: fetch,
   })
 
@@ -274,6 +291,7 @@ export function apply(ctx, config) {
         usagePercent: info.usagePercent,
         quota: info.quota || null,
         usage: info.usage || null,
+        requests: store.getRequestCount(slot.ref) || null,
         refreshError: info.refreshError || '',
         validationUrl: info.validationUrl || '',
         validationMessage: info.validationMessage || '',
@@ -335,6 +353,50 @@ export function apply(ctx, config) {
     return () => clear(id)
   }, 'dsh-subscriptions: refresh ahead')
 
+  // Фоновый health-check: раз в N минут прогоняет дешёвый check по всем
+  // подключённым аккаунтам. Мёртвые помечаются через describeRef, cooldown
+  // не ставится (как в /check).
+  ctx.effect(() => {
+    const tick = async () => {
+      const cfg = live()
+      const mins = Number(cfg.probeIntervalMin)
+      if (!Number.isFinite(mins) || mins <= 0) return
+      const now = Date.now()
+      for (const slot of normalizeSlots(cfg.slots)) {
+        const ref = slot.ref
+        try {
+          const info = await store.describeRef(ref)
+          if (!info.configured) continue
+          const raw = await store.resolveRaw(ref)
+          if (!raw) continue
+          const blob = await store.loadBlob(ref).catch(() => null)
+          if (!blob || !blob.refreshToken) continue
+          const fresh = await store.ensureFresh(slot.provider, blob, ref).catch(() => null)
+          if (!fresh) continue
+          const vendor = getVendor(slot.provider)
+          if (typeof vendor.check !== 'function') continue
+          const cfg2 = vendorConfig(slot.provider, live())
+          const probeFetch = async (u, i) => fetch(u, i)
+          await vendor.check(fresh, cfg2, probeFetch).catch((e) => {
+            try { ctx.log && ctx.log.warn && ctx.log.warn("[dsh-subscriptions] probe " + ref + ": " + String(e && e.message || e).slice(0, 200)) } catch {}
+          })
+        } catch {}
+      }
+    }
+    let lastProbeAt = 0
+    const wrapped = async () => {
+      const cfg = live()
+      const mins = Number(cfg.probeIntervalMin)
+      if (!Number.isFinite(mins) || mins <= 0) return
+      if (Date.now() - lastProbeAt < mins * 60 * 1000) return
+      lastProbeAt = Date.now()
+      await tick()
+    }
+    wrapped().catch(() => {})
+    const timer = setInterval(() => { wrapped().catch(() => {}) }, 60 * 1000)
+    return () => clearInterval(timer)
+  }, 'dsh-subscriptions: probe loop')
+
 
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
@@ -559,6 +621,151 @@ export function apply(ctx, config) {
     },
   }), 'dsh-subscriptions: /check')
 
+  // HTTP-прокси к API провайдера через subscriptions.request.
+  // Same-origin only, allowlist путей, ротация и квота как у моделей.
+  // Токен наружу не отдаётся — наружу только ответ провайдера.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'prefix',
+    path: '/dsh-subscriptions/proxy',
+    handler: async (req, res) => {
+      if (req.method !== 'POST' && req.method !== 'GET') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'GET or POST' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      const url = new URL(req.url || '/', 'http://localhost')
+      const parts = url.pathname.replace(/^\/dsh-subscriptions\/proxy\//, '').split('/').filter(Boolean)
+      const provider = parts[0]
+      const restPath = '/' + parts.slice(1).join('/')
+      if (!isProvider(provider)) {
+        writeJson(res, 404, { ok: false, error: { code: 'provider', message: 'unknown provider' } })
+        return
+      }
+      let body
+      if (req.method === 'POST') {
+        try {
+          body = JSON.parse((await readBody(req, 1024 * 1024)).toString('utf8'))
+        } catch {
+          writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+          return
+        }
+      }
+      try {
+        const out = await subscriptions.request({
+          provider,
+          path: restPath,
+          method: req.method === 'POST' ? 'POST' : 'GET',
+          body,
+          headers: {},
+        })
+        const text = await out.text()
+        try {
+          const json = JSON.parse(text)
+          writeJson(res, out.status || 200, json)
+        } catch {
+          res.writeHead(out.status || 200, { 'Content-Type': 'application/json' })
+          res.end(text)
+        }
+      } catch (e) {
+        const status = e && e.status ? e.status : (e && e.code === 'FORBIDDEN' ? 403 : (e && e.code === 'AUTH' ? 401 : 502))
+        writeJson(res, status, { ok: false, error: { code: e && e.code || 'VENDOR', message: String(e && e.message || e).slice(0, 300) } })
+      }
+    },
+  }), 'dsh-subscriptions: proxy')
+
+  // Экспорт зашифрованного бандла токенов. Токены не логгируются.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/export',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let payload
+      try { payload = JSON.parse((await readBody(req, 8 * 1024)).toString('utf8') || '{}') } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      const passphrase = payload.passphrase
+      if (!passphrase || typeof passphrase !== 'string') {
+        writeJson(res, 400, { ok: false, error: { code: 'passphrase', message: 'нужен passphrase' } })
+        return
+      }
+      try {
+        const accounts = []
+        for (const slot of normalizeSlots(live().slots)) {
+          try {
+            const blob = await store.loadBlob(slot.ref)
+            accounts.push({ ref: slot.ref, provider: slot.provider, index: slot.index, label: slot.label || blob.label || '', blob })
+          } catch { /* skip missing */ }
+        }
+        if (!accounts.length) {
+          writeJson(res, 200, { ok: false, error: { code: 'empty', message: 'нет подключённых аккаунтов' } })
+          return
+        }
+        const bundle = JSON.stringify({ v: 1, exportedAt: Date.now(), accounts })
+        const encrypted = encryptWithPassphrase(bundle, passphrase)
+        writeJson(res, 200, { ok: true, payload: encrypted, count: accounts.length })
+      } catch (e) {
+        writeJson(res, 500, { ok: false, error: { code: 'export', message: String(e && e.message || e) } })
+      }
+    },
+  }), 'dsh-subscriptions: /export')
+
+  // Импорт зашифрованного бандла.
+  ctx.effect(() => ctx.webServer.register({
+    kind: 'exact',
+    path: '/dsh-subscriptions/import',
+    handler: async (req, res) => {
+      if (req.method !== 'POST') {
+        writeJson(res, 405, { ok: false, error: { code: 'method', message: 'POST only' } })
+        return
+      }
+      if (!isTrustedSettingsRequest(req)) {
+        writeJson(res, 403, { ok: false, error: { code: 'forbidden', message: 'same-origin only' } })
+        return
+      }
+      let payload
+      try { payload = JSON.parse((await readBody(req, 1024 * 1024)).toString('utf8') || '{}') } catch {
+        writeJson(res, 400, { ok: false, error: { code: 'json', message: 'invalid json' } })
+        return
+      }
+      const { passphrase, payload: encrypted } = payload
+      if (!passphrase || !encrypted) {
+        writeJson(res, 400, { ok: false, error: { code: 'params', message: 'нужны passphrase и payload' } })
+        return
+      }
+      let bundle
+      try {
+        bundle = JSON.parse(decryptWithPassphrase(encrypted, passphrase))
+      } catch (e) {
+        writeJson(res, 400, { ok: false, error: { code: 'decrypt', message: 'неверный passphrase или повреждённый бандл' } })
+        return
+      }
+      if (!bundle || !Array.isArray(bundle.accounts)) {
+        writeJson(res, 400, { ok: false, error: { code: 'format', message: 'неверный формат бандла' } })
+        return
+      }
+      let imported = 0
+      for (const row of bundle.accounts) {
+        try {
+          await store.saveBlob(row.ref, row.blob)
+          imported++
+        } catch { /* skip broken */ }
+      }
+      await syncAdapter()
+      writeJson(res, 200, { ok: true, imported, total: bundle.accounts.length, accounts: await accountsView() })
+    },
+  }), 'dsh-subscriptions: /import')
+
   ctx.effect(() => ctx.webServer.register({
     kind: 'exact',
     path: '/dsh-subscriptions/logout',

package/lib/rotate.js

@@ -23,11 +23,19 @@ export function pickAccount(accounts, nowMs, opts) {
     if (!q) return false
     if (q.resetAt && Number(q.resetAt) <= now) return false
     if (q.remaining == null) return false
+    // Если до сброса меньше минуты — переключаемся, не тратя остаток,
+    // независимо от порога (аккаунт всё равно скоро обнулится).
+    if (q.resetAt && Number(q.resetAt) - now < 60000) return true
+    // Если остаток меньше порога — считаем исчерпанным, чтобы не тратить
+    // последние проценты перед отказом.
+    let below = false
     if (q.limit != null && q.limit > 0 && thr > 0 && thr < 1) {
       const frac = q.remaining / q.limit
-      return frac <= thr
+      below = frac <= thr
+    } else {
+      below = q.remaining <= thr
     }
-    return q.remaining <= thr
+    return below
   }
   function isUsageExhausted(acc) {
     if (acc.usagePercent == null || Number(acc.usagePercent) < 100) return false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-subscriptions",
-  "version": "0.2.11",
+  "version": "0.3.1",
   "description": "Use ChatGPT Codex, Claude, Grok, and Antigravity subscriptions as DeepSeek Harness LLM providers via OAuth.",
   "license": "MIT",
   "type": "module",