@goodandready/dsh-clinebot 0.3.25 → 0.4.1

package/lib/cline-client.js

@@ -6,7 +6,6 @@
  */
 
 import {
-  CLINE_MODELS,
   DEFAULT_MODEL_ID,
   PROVIDER_ID,
   PROVIDER_DISPLAY_NAME,
@@ -51,46 +50,12 @@ export function normalizeBaseUrl(raw) {
   return s
 }
 
-// In-memory runtime session metrics for ClinePass requests
-export const sessionStats = {
-  totalRequests: 0,
-  successfulRequests: 0,
-  failedRequests: 0,
-  promptTokensEst: 0,
-  completionTokensEst: 0,
-  totalTokensEst: 0,
-  lastLatencyMs: null,
-  lastRequestAt: null,
-  lastError: null,
-}
-
-export function recordSessionRequest({ latencyMs, ok, error, promptTokens = 0, completionTokens = 0 }) {
-  sessionStats.totalRequests += 1
-  if (ok) {
-    sessionStats.successfulRequests += 1
-    sessionStats.lastLatencyMs = typeof latencyMs === 'number' ? latencyMs : null
-    sessionStats.lastError = null
-  } else {
-    sessionStats.failedRequests += 1
-    sessionStats.lastError = error || 'Request failed'
-  }
-  sessionStats.lastRequestAt = Date.now()
-  sessionStats.promptTokensEst += Number(promptTokens) || 0
-  sessionStats.completionTokensEst += Number(completionTokens) || 0
-  sessionStats.totalTokensEst += (Number(promptTokens) || 0) + (Number(completionTokens) || 0)
-}
-
-export function resetSessionStats() {
-  sessionStats.totalRequests = 0
-  sessionStats.successfulRequests = 0
-  sessionStats.failedRequests = 0
-  sessionStats.promptTokensEst = 0
-  sessionStats.completionTokensEst = 0
-  sessionStats.totalTokensEst = 0
-  sessionStats.lastLatencyMs = null
-  sessionStats.lastRequestAt = null
-  sessionStats.lastError = null
-}
+export {
+  sessionStats,
+  recordSessionRequest,
+  recordSmokeTest,
+  resetSessionStats,
+} from './telemetry.js'
 
 /**
  * Resolve API key from environment variables.
@@ -124,6 +89,26 @@ export async function saveCredentialKey(ctx, apiKeyEnv, apiKey) {
   return { ok: true, envName: name }
 }
 
+/**
+ * Delete API key from DSH credentials service.
+ */
+export async function deleteCredentialKey(ctx, apiKeyEnv) {
+  const name = String(apiKeyEnv || '').trim()
+  if (!name) return { ok: false }
+  const credentials = ctx?.credentials || ctx?.get?.('credentials')
+  if (!credentials) return { ok: false }
+  try {
+    const ref = await toCredentialRef(name)
+    if (typeof credentials.unset === 'function') {
+      await credentials.unset(ref)
+      return { ok: true, envName: name }
+    }
+  } catch (err) {
+    console.warn('[dsh-clinebot] Failed unsetting credential:', err)
+  }
+  return { ok: false }
+}
+
 function abortAfter(ms) {
   const ac = new AbortController()
   const timer = setTimeout(() => ac.abort(), Math.max(1, Number(ms) || DEFAULT_TIMEOUT_MS))
@@ -279,7 +264,7 @@ export async function fetchUsageLimits(baseUrl, apiKey, {
 
       let userEmail = null
       let createdAt = null
-      let planDisplayName = 'ClinePass ($9.99/mo)'
+      let planDisplayName = 'ClinePass'
       let dynamicModels = []
 
       try {
@@ -297,8 +282,14 @@ export async function fetchUsageLimits(baseUrl, apiKey, {
         if (planRes?.ok) {
           const planData = await planRes.json().catch(() => ({}))
           const plan = planData?.data?.plan || planData?.data || planData?.plan || planData
-          if (plan?.displayName || plan?.title || plan?.name) {
-            planDisplayName = `${plan.displayName || plan.title || plan.name} ($${((plan.pricePerSeatCents || plan.priceInCents || 999) / 100).toFixed(2)}/mo)`
+          const name = plan?.displayName || plan?.title || plan?.name || 'ClinePass'
+          const priceCents = typeof plan?.pricePerSeatCents === 'number'
+            ? plan.pricePerSeatCents
+            : (typeof plan?.priceInCents === 'number' ? plan.priceInCents : null)
+          if (priceCents !== null) {
+            planDisplayName = `${name} ($${(priceCents / 100).toFixed(2)}/mo)`
+          } else {
+            planDisplayName = name
           }
           const featuresIncluded = plan?.features?.included || plan?.includedModels
           if (featuresIncluded) {
@@ -434,6 +425,15 @@ export async function smokeChat(baseUrl, apiKey, {
   fetchImpl = fetch,
 } = {}) {
   const base = normalizeBaseUrl(baseUrl)
+  try {
+    const parsed = new URL(base)
+    if (parsed.protocol !== 'https:' && parsed.hostname !== 'localhost' && parsed.hostname !== '127.0.0.1') {
+      return { ok: false, error: 'Insecure protocol: smokeChat requires https: for remote endpoints' }
+    }
+  } catch (err) {
+    return { ok: false, error: `Invalid baseUrl: ${err?.message || err}` }
+  }
+
   if (!apiKey) {
     return { ok: false, error: 'Missing API key. Set credential or environment variable.' }
   }
@@ -587,4 +587,4 @@ export async function resolveKeyValue(ctx, apiKeyEnv) {
 }
 
 
-export { resolveAccountPool, isAccountQuotaExhausted, rotateToNextAccount } from './account-pool.js'
+export { resolveAccountPool, isAccountQuotaExhausted, rotateToNextAccount, getLastRotation, setLastRotation, isQuotaExceededError } from './account-pool.js'

package/lib/config.js

@@ -51,6 +51,8 @@ export const Config = z.object({
     reasoningEfforts: z.any().default(undefined),
   })).default([])
     .description('Models automatically discovered from the official ClinePass subscription plan.'),
+  planSyncedAt: z.number().default(0)
+    .description('Timestamp when models were last synchronized with active subscription plan.').volatile(),
   timeoutMs: z.number().default(DEFAULT_TIMEOUT_MS)
     .description('HTTP probe timeout in milliseconds.').volatile(),
   smokeTimeoutMs: z.number().default(DEFAULT_SMOKE_TIMEOUT_MS)
@@ -99,22 +101,41 @@ export function volatileConfig(cfg) {
 export function publicConfig(cfg) {
   cfg = plainConfig(cfg)
   const dynamic = Array.isArray(cfg?.dynamicModels) ? cfg.dynamicModels : []
-  const allDefaultIds = getDefaultModelIds(dynamic)
+  const isSynced = dynamic.length > 0
+  const allModels = getAllModels(dynamic)
+  const allDefaultIds = allModels.map((m) => m.id)
 
   let disabledList = Array.isArray(cfg?.disabledModels) ? cfg.disabledModels : []
-  if (!Array.isArray(cfg?.disabledModels) || (cfg.disabledModels.length === 0 && Array.isArray(cfg?.enabledModels) && cfg.enabledModels.length > 0)) {
+  if (cfg?.disabledModels === undefined && Array.isArray(cfg?.enabledModels) && cfg.enabledModels.length > 0) {
     const enabledSet = new Set(cfg.enabledModels)
     disabledList = allDefaultIds.filter((id) => !enabledSet.has(id))
   }
 
-  const activeIds = getActiveModelIds(allDefaultIds, disabledList)
+  let activeIds = getActiveModelIds(allDefaultIds, disabledList)
+  if (!activeIds.length && allDefaultIds.length) {
+    activeIds = [allDefaultIds[0]]
+  }
+
+  let defaultModel = cfg?.defaultModel || DEFAULT_MODEL_ID
+  let defaultModelWarning = null
+
+  if (allDefaultIds.length > 0 && !allDefaultIds.includes(defaultModel)) {
+    const fallbackModel = activeIds[0] || allDefaultIds[0]
+    defaultModelWarning = `Configured default model "${defaultModel}" is not available in your active plan. Using "${fallbackModel}" instead.`
+    defaultModel = fallbackModel
+  }
+
+  const planSyncedAt = Number(cfg?.planSyncedAt) || (isSynced ? (dynamic.planSyncedAt || 0) : 0)
 
   return {
     enabled: !!cfg?.enabled,
     baseUrl: normalizeBaseUrl(cfg?.baseUrl),
     apiKeyEnv: cfg?.apiKeyEnv || DEFAULT_API_KEY_ENV,
-    defaultModel: cfg?.defaultModel || DEFAULT_MODEL_ID,
+    defaultModel,
+    defaultModelWarning,
     dynamicModels: dynamic,
+    planSynced: isSynced,
+    planSyncedAt,
     disabledModels: disabledList,
     enabledModels: activeIds,
     timeoutMs: Number(cfg?.timeoutMs) || DEFAULT_TIMEOUT_MS,

package/lib/http.js

@@ -10,7 +10,20 @@ export function writeJson(res, code, body) {
   }
 }
 
-export function readBody(req, maxBytes = 256 * 1024) {
+export async function readBody(req, maxBytes = 256 * 1024) {
+  if (typeof req?.[Symbol.asyncIterator] === 'function') {
+    const chunks = []
+    let size = 0
+    for await (const chunk of req) {
+      const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)
+      size += buf.length
+      if (size > maxBytes) {
+        throw new Error('body too large')
+      }
+      chunks.push(buf)
+    }
+    return Buffer.concat(chunks)
+  }
   return new Promise((resolve, reject) => {
     const chunks = []
     let size = 0
@@ -18,7 +31,7 @@ export function readBody(req, maxBytes = 256 * 1024) {
       size += c.length
       if (size > maxBytes) {
         reject(new Error('body too large'))
-        req.destroy()
+        req.destroy?.()
         return
       }
       chunks.push(c)

package/lib/index.js

@@ -8,7 +8,9 @@ import {
   resolveKeyValue,
   smokeChat,
   fetchUsageLimits,
+  isQuotaExceededError,
 } from './cline-client.js'
+import { PROVIDER_ID } from './models.js'
 import {
   checkRegisteredInPiAi,
   upsertPiAiProvider,
@@ -38,13 +40,11 @@ export function apply(ctx, config) {
     try {
       const pub = publicConfig(cfg)
       if (!pub.enabled) {
-        if (await checkRegisteredInPiAi(ctx)) {
-          await removePiAiProvider(ctx)
-        }
+        await removePiAiProvider(ctx)
         return
       }
-      const key = await resolveKeyValue(ctx, pub.apiKeyEnv)
-      if (key.value) {
+      const activeKey = await resolveActiveAccountKey(ctx, cfg)
+      if (activeKey.value) {
         await upsertPiAiProvider(ctx, cfg, pub.enabledModels)
       }
     } catch {
@@ -116,20 +116,6 @@ export function apply(ctx, config) {
         settingsApi = undefined
       })
     })
-  } else {
-    const settingsService = (ctx?.get && ctx.get('settings')) || ctx?.settings
-    if (typeof settingsService?.register === 'function') {
-      const scope = settingsService.register(NS, Config, { base: config })
-      settingsApi = scope
-      getConfig = () => (scope?.get?.() ?? config) ?? config
-      if (typeof ctx.effect === 'function') {
-        ctx.effect(() => scope.watch((next) => {
-          syncProviderState(live())
-        }), 'dsh-clinebot: settings')
-      }
-    } else {
-      settingsApi = createSettingsAdapter(settingsService)
-    }
   }
 
   syncProviderState(live())
@@ -138,8 +124,6 @@ export function apply(ctx, config) {
       const timer = setTimeout(triggerAutoDiscover, 500)
       return () => clearTimeout(timer)
     }, 'dsh-clinebot: auto-discover')
-  } else {
-    setTimeout(triggerAutoDiscover, 500)
   }
 
   if (ctx.webServer?.register) {
@@ -171,35 +155,118 @@ export function apply(ctx, config) {
     syncProviderState,
   })
 
-  return {
-    getStatus: () => buildStatus(ctx, live()),
-    registerProvider: (models) => upsertPiAiProvider(ctx, live(), models),
-    unregisterProvider: () => removePiAiProvider(ctx),
-    recordRequestMetrics: (metrics) => recordSessionRequest(metrics),
-    getSessionStats: () => ({ ...sessionStats }),
-    getUsageLimits: async () => {
-      const pub = publicConfig(live())
-      const key = await resolveKeyValue(ctx, pub.apiKeyEnv)
-      return fetchUsageLimits(pub.baseUrl, key.value)
-    },
-    runSmokeTest: async (model) => {
-      const pub = publicConfig(live())
-      const activeKey = await resolveActiveAccountKey(ctx, live())
-      const res = await smokeChat(pub.baseUrl, activeKey.value, { model: model || pub.defaultModel })
-      recordSessionRequest({
-        latencyMs: res.latencyMs,
-        ok: res.ok,
-        error: res.error,
-        promptTokens: res.promptTokens || 5,
-        completionTokens: res.completionTokens || 10,
-      })
-      if (res.status === 429) {
-        const failover = await rotateToNextAccount(ctx, live(), 'service_429', settingsApi)
-        if (failover.rotated) {
-          await syncProviderState(live())
-        }
+  let lastFailoverAt = 0
+
+  const handleStream429 = async () => {
+    const now = Date.now()
+    if (now - lastFailoverAt < 30000) {
+      ctx?.logger?.warn?.('[dsh-clinebot] Suppressing rapid failover rotation within 30s storm window')
+      return
+    }
+    lastFailoverAt = now
+    try {
+      const failover = await rotateToNextAccount(ctx, live(), 'stream_429', settingsApi)
+      if (failover?.rotated) {
+        await syncProviderState(live())
       }
-      return res
-    },
+    } catch (err) {
+      ctx?.logger?.warn?.('[dsh-clinebot] Auto-failover rotation failed: ' + (err?.message || err))
+    }
+  }
+
+  if (typeof ctx.on === 'function') {
+    const unlisten = ctx.on('llm/stream', (options, next) => {
+      const isCline = options?.provider === PROVIDER_ID
+      const stream = next()
+      const startTime = Date.now()
+      let promptTokens = 0
+      let completionTokens = 0
+      let finished = false
+
+      return (async function* () {
+        try {
+          for await (const chunk of stream) {
+            if (isCline && chunk?.type === 'usage' && chunk?.usage) {
+              const u = chunk.usage
+              promptTokens += (Number(u.inputTokens) || 0) + (Number(u.cacheReadTokens) || 0) + (Number(u.cacheWriteTokens) || 0)
+              completionTokens += Number(u.outputTokens) || 0
+            }
+            if (isCline && chunk?.type === 'finish' && chunk?.reason) {
+              finished = true
+              const latencyMs = Date.now() - startTime
+              const reason = chunk.reason
+              const failure = reason.failure || {}
+              const isError = reason.kind === 'error'
+              const isAborted = reason.kind === 'aborted'
+              const is429 = failure.status === 429 || failure.code === 429 || failure.code === 'rate_limit_exceeded'
+              const isExceeded = isQuotaExceededError(`${failure.message || ''} ${failure.code || ''}`)
+
+              if (isError) {
+                recordSessionRequest({
+                  latencyMs,
+                  ok: false,
+                  error: failure.message || 'Stream error',
+                  promptTokens,
+                  completionTokens,
+                  model: options?.model,
+                })
+                if (is429 || isExceeded) {
+                  handleStream429()
+                }
+              } else if (isAborted) {
+                recordSessionRequest({
+                  latencyMs,
+                  ok: true,
+                  aborted: true,
+                  promptTokens,
+                  completionTokens,
+                  model: options?.model,
+                })
+              } else {
+                recordSessionRequest({
+                  latencyMs,
+                  ok: true,
+                  promptTokens,
+                  completionTokens,
+                  model: options?.model,
+                })
+              }
+            }
+            yield chunk
+          }
+          if (isCline && !finished) {
+            recordSessionRequest({
+              latencyMs: Date.now() - startTime,
+              ok: true,
+              promptTokens,
+              completionTokens,
+              model: options?.model,
+            })
+          }
+        } catch (err) {
+          if (isCline) {
+            const latencyMs = Date.now() - startTime
+            const status = err?.status || err?.statusCode
+            const msg = String(err?.message || err)
+            recordSessionRequest({
+              latencyMs,
+              ok: false,
+              error: msg,
+              promptTokens,
+              completionTokens,
+              model: options?.model,
+            })
+            if (status === 429 || isQuotaExceededError(msg)) {
+              handleStream429()
+            }
+          }
+          throw err
+        }
+      })()
+    }, { global: true, prepend: true })
+
+    if (typeof ctx.effect === 'function') {
+      ctx.effect(() => () => unlisten?.(), 'dsh-clinebot: llm/stream failover')
+    }
   }
 }

package/lib/models.js

@@ -18,7 +18,7 @@ export const CLINE_MODELS = Object.freeze([
     id: 'cline-pass/deepseek-v4-flash',
     name: 'DeepSeek V4 Flash',
     description: 'High-speed reasoning & code completion model optimized for agentic loops.',
-    contextLength: 200000,
+    contextLength: 128000,
     maxTokens: 8192,
     input: ['text', 'image'],
     category: 'coding',
@@ -30,7 +30,7 @@ export const CLINE_MODELS = Object.freeze([
     id: 'cline-pass/deepseek-v4-pro',
     name: 'DeepSeek V4 Pro',
     description: 'Flagship reasoning and multi-turn architectural coding model.',
-    contextLength: 200000,
+    contextLength: 128000,
     maxTokens: 8192,
     input: ['text', 'image'],
     category: 'coding',
@@ -42,7 +42,7 @@ export const CLINE_MODELS = Object.freeze([
     id: 'cline-pass/glm-5.2',
     name: 'GLM 5.2',
     description: 'Bilingual general & coding model with strong instruction following.',
-    contextLength: 200000,
+    contextLength: 128000,
     maxTokens: 8192,
     input: ['text'],
     category: 'general',
@@ -88,7 +88,7 @@ export const CLINE_MODELS = Object.freeze([
     id: 'cline-pass/qwen3.7-max',
     name: 'Qwen 3.7 Max',
     description: 'Large-scale multimodal foundation model from Alibaba Cloud with reasoning support.',
-    contextLength: 200000,
+    contextLength: 128000,
     maxTokens: 8192,
     input: ['text', 'image'],
     category: 'multimodal',
@@ -100,7 +100,7 @@ export const CLINE_MODELS = Object.freeze([
     id: 'cline-pass/qwen3.7-plus',
     name: 'Qwen 3.7 Plus',
     description: 'Fast, capable multimodal model with strong multilingual skills and reasoning.',
-    contextLength: 200000,
+    contextLength: 128000,
     maxTokens: 8192,
     input: ['text', 'image'],
     category: 'multimodal',
@@ -124,7 +124,7 @@ export const CLINE_MODELS = Object.freeze([
     id: 'cline-pass/mimo-v2.5',
     name: 'MiMo V2.5',
     description: 'Xiaomi MiMo efficient instruction model with reasoning and multimodal support.',
-    contextLength: 200000,
+    contextLength: 128000,
     maxTokens: 8192,
     input: ['text', 'image'],
     category: 'general',
@@ -136,7 +136,7 @@ export const CLINE_MODELS = Object.freeze([
     id: 'cline-pass/mimo-v2.5-pro',
     name: 'MiMo V2.5 Pro',
     description: 'Xiaomi MiMo advanced agentic reasoning model with multimodal support.',
-    contextLength: 200000,
+    contextLength: 128000,
     maxTokens: 8192,
     input: ['text', 'image'],
     category: 'coding',
@@ -168,12 +168,12 @@ export function parsePlanIncludedModels(includedInput) {
   const clean = includedText
     .replace(/^includes\s+/i, '')
     .replace(/\band\b/gi, ',')
-    .replace(/\./g, '')
+    .replace(/[.;]+$/g, '')
     .trim()
 
   const parts = clean
     .split(',')
-    .map((p) => p.trim())
+    .map((p) => p.trim().replace(/[.;]+$/g, '').trim())
     .filter(Boolean)
 
   const normalize = (s) =>
@@ -193,7 +193,14 @@ export function parsePlanIncludedModels(includedInput) {
       matched.push(found)
     } else {
       // Dynamic fallback for newly introduced models mentioned in plan
-      const idPart = name.toLowerCase().replace(/[\s_]+/g, '-')
+      const idPart = name
+        .toLowerCase()
+        .trim()
+        .replace(/^cline-pass\//, '')
+        .replace(/qwen\s+([0-9])/i, 'qwen$1')
+        .replace(/glm\s+([0-9])/i, 'glm-$1')
+        .replace(/[\s_]+/g, '-')
+        .replace(/-+/g, '-')
       const isVision = /(vision|vl|multimodal|omni|image)/i.test(name)
       const hasReasoning = /(reason|think|r1|pro|flash|max|plus|k3|m3|glm|qwen|mimo)/i.test(name)
       matched.push({
@@ -215,27 +222,49 @@ export function parsePlanIncludedModels(includedInput) {
 }
 
 /**
- * Get all models from known catalog.
+ * Get all models:
+ * 1. When plan is synchronized (dynamicModels is a non-empty array):
+ *    Registers strictly the models included in the active plan, enriching them
+ *    with curated capabilities, reasoning efforts, and descriptions from CLINE_MODELS.
+ * 2. When plan is unsynced (dynamicModels is empty):
+ *    Falls back to the full curated CLINE_MODELS catalog marked with unverified: true.
  */
 export function getAllModels(dynamicModels = []) {
-  const result = [...CLINE_MODELS]
-  const seenIds = new Set(result.map((m) => m.id))
-
-  if (Array.isArray(dynamicModels)) {
-    for (const item of dynamicModels) {
-      if (item && item.id && !seenIds.has(item.id)) {
-        result.push(item)
-        seenIds.add(item.id)
+  if (Array.isArray(dynamicModels) && dynamicModels.length > 0) {
+    const normalize = (s) => String(s || '').toLowerCase().replace(/[\s._-]+/g, '')
+    return dynamicModels.map((dm) => {
+      const targetNorm = normalize(dm.id.replace(/^cline-pass\//, ''))
+      const curated = CLINE_MODELS.find(
+        (cm) => cm.id === dm.id || normalize(cm.id.replace(/^cline-pass\//, '')) === targetNorm || normalize(cm.name) === targetNorm
+      )
+      if (curated) {
+        return {
+          ...curated,
+          ...dm,
+          description: dm.description || curated.description,
+          contextLength: dm.contextLength || curated.contextLength,
+          maxTokens: dm.maxTokens || curated.maxTokens,
+          input: dm.input && dm.input.length ? dm.input : curated.input,
+          category: dm.category || curated.category,
+          reasoningEfforts: dm.reasoningEfforts !== undefined ? dm.reasoningEfforts : curated.reasoningEfforts,
+          unverified: false,
+        }
       }
-    }
+      return {
+        ...dm,
+        unverified: false,
+      }
+    })
   }
 
-  return result
+  return CLINE_MODELS.map((m) => ({ ...m, unverified: true }))
 }
 
 export function findModel(id, dynamicModels = []) {
   const all = getAllModels(dynamicModels)
-  return all.find((m) => m.id === id) || null
+  const found = all.find((m) => m.id === id)
+  if (found) return found
+  return CLINE_MODELS.find((m) => m.id === id) || null
 }
 
 export function isSupportedModel(id, dynamicModels = []) {
@@ -298,14 +327,14 @@ export function isVisionModel(id, dynamicModels = []) {
 /**
  * Disk caching for discovered models.
  */
-export async function saveModelsDiskCache(cachePath, models = []) {
+export async function saveModelsDiskCache(cachePath, models = [], planSyncedAt = Date.now()) {
   if (!cachePath || !Array.isArray(models) || !models.length) return false
   try {
     const fs = await import('node:fs/promises')
     const path = await import('node:path')
     const dir = path.dirname(cachePath)
     await fs.mkdir(dir, { recursive: true })
-    const payload = JSON.stringify({ savedAt: Date.now(), models }, null, 2)
+    const payload = JSON.stringify({ savedAt: Date.now(), planSyncedAt, models }, null, 2)
     await fs.writeFile(cachePath, payload, 'utf8')
     return true
   } catch {
@@ -319,7 +348,10 @@ export async function loadModelsDiskCache(cachePath) {
     const fs = await import('node:fs/promises')
     const raw = await fs.readFile(cachePath, 'utf8')
     const parsed = JSON.parse(raw)
-    return Array.isArray(parsed?.models) ? parsed.models : null
+    const list = Array.isArray(parsed?.models) ? parsed.models : (Array.isArray(parsed) ? parsed : null)
+    if (!list) return null
+    list.planSyncedAt = typeof parsed?.planSyncedAt === 'number' ? parsed.planSyncedAt : (typeof parsed?.savedAt === 'number' ? parsed.savedAt : 0)
+    return list
   } catch {
     return null
   }