@linxin666/dsh-usage 0.4.3 → 0.4.5

package/src/host/usage-service.ts

@@ -20,7 +20,7 @@ import type { BalanceParse, PlanParse } from '../core/adapters.ts'
 import { foldAliasRoutes } from '../core/provider-routes.ts'
 import { deepseekModelSpend } from '../core/pricing.ts'
 import { createLedgerDocument, deserializeLedger, foldUsage, ledgerDayKeys, localDateKey, pruneLedger, summarizeDays, totalTokens } from '../core/ledger.ts'
-import type { BalanceView, CredentialKind, ObservedSpendView, PlanView, ProviderSnapshotState, ProviderSnapshotView, UsageLedgerDocument, UsageOverviewView, UsageTokenTotals } from '../core/types.ts'
+import type { BalanceView, CredentialKind, ObservedSpendView, PlanView, ProviderSnapshotState, ProviderSnapshotView, UsageDayView, UsageLedgerDocument, UsageOverviewView, UsageTokenTotals } from '../core/types.ts'
 import { addTotals, emptyTotals } from '../core/types.ts'
 
 /**
@@ -103,19 +103,129 @@ async function writeJsonAtomic(path: string, value: unknown): Promise<void> {
   }
 }
 
+function unwrapVolatiles(value: unknown): unknown {
+  if (value === null || value === undefined) return value
+  if (typeof value === 'object') {
+    if (typeof (value as { get?: unknown }).get === 'function') {
+      return unwrapVolatiles((value as { get(): unknown }).get())
+    }
+    if (Array.isArray(value)) {
+      return value.map(unwrapVolatiles)
+    }
+    const result: Record<string, unknown> = {}
+    for (const [k, v] of Object.entries(value)) {
+      result[k] = unwrapVolatiles(v)
+    }
+    return result
+  }
+  return value
+}
+
+function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+function deepMerge(base: unknown, patch: unknown): unknown {
+  if (!isPlainObject(base) || !isPlainObject(patch)) return patch !== undefined ? patch : base
+  const result: Record<string, unknown> = { ...base }
+  for (const [key, value] of Object.entries(patch)) {
+    if (value === undefined) continue
+    result[key] = isPlainObject(value) && isPlainObject(result[key]) ? deepMerge(result[key], value) : value
+  }
+  return result
+}
+
 /**
  * Read a foreign settings namespace's resolved value (the llm adapter
- * profiles, the agent default model). Unregistered namespaces read as
- * undefined; nothing here throws into the poll loop.
+ * profiles, the agent default model). Resolves across pre-0.1.7 settings.get(),
+ * 0.1.7 SettingsForms.describe(), live loader entries, and configEditor.
+ * Unregistered namespaces read as undefined; nothing here throws into the poll loop.
  */
 function readNamespace(ctx: Context, ns: string): unknown {
   try {
-    const settings = service<{ get(ns: unknown): unknown }>(ctx, 'settings')
-    if (settings === undefined) return undefined
-    return settings.get(ns)
+    // 1. Try legacy settings.get(ns) or 0.1.7 settings.describe()
+    const settings = service<{
+      get?(ns: unknown): unknown
+      describe?(options?: unknown): Array<{ ns: string; value: unknown }>
+    }>(ctx, 'settings')
+    if (settings !== undefined) {
+      if (typeof settings.get === 'function') {
+        const value = settings.get(ns)
+        if (value !== undefined) return unwrapVolatiles(value)
+      }
+      if (typeof settings.describe === 'function') {
+        const descriptors = settings.describe({ redactSecrets: false })
+        if (Array.isArray(descriptors)) {
+          const match = descriptors.find((d) =>
+            d.ns === ns
+            || (ns === 'llm-pi-ai' && (d.ns === 'llm' || isPlainObject((d.value as { providers?: unknown })?.providers)))
+            || (ns === 'llm-deepseek' && (d.ns === 'llm-deepseek' || d.ns === 'llm-deepseek-api-key'))
+          )
+          if (match !== undefined && match.value !== undefined) {
+            return unwrapVolatiles(match.value)
+          }
+        }
+      }
+    }
+
+    // 2. Try ctx.root.loader or ctx.loader entries
+    const loader = (ctx as unknown as {
+      root?: { loader?: { entries(): Iterable<{ options: { id: string; name?: string }; fiber?: { config?: unknown } }> } }
+      loader?: { entries(): Iterable<{ options: { id: string; name?: string }; fiber?: { config?: unknown } }> }
+    }).root?.loader
+      ?? (ctx as unknown as {
+        loader?: { entries(): Iterable<{ options: { id: string; name?: string }; fiber?: { config?: unknown } }> }
+      }).loader
+    if (loader !== undefined && typeof loader.entries === 'function') {
+      for (const entry of loader.entries()) {
+        const id = entry.options?.id
+        const name = entry.options?.name
+        if (
+          id === ns
+          || name === `@deepseek-ai/dsh-${ns}`
+          || name?.endsWith(`/${ns}`)
+          || (ns === 'llm-pi-ai' && (id === 'llm' || name === '@deepseek-ai/dsh-llm-pi-ai'))
+          || (ns === 'llm-deepseek' && (id === 'llm-deepseek-api-key' || name === '@deepseek-ai/dsh-llm-deepseek-api-key'))
+        ) {
+          if (entry.fiber?.config !== undefined) {
+            return unwrapVolatiles(entry.fiber.config)
+          }
+        }
+      }
+    }
+
+    // 3. Try configEditor service
+    const editor = service<{
+      configuration?(): Array<{
+        entry: { options: { id: string; name?: string }; fiber?: { config?: unknown } }
+        inherited: Record<string, unknown>
+        override: Record<string, unknown>
+      }>
+    }>(ctx, 'configEditor')
+    if (editor !== undefined && typeof editor.configuration === 'function') {
+      const rows = editor.configuration()
+      const match = rows.find((r) => {
+        const id = r.entry.options.id
+        const name = r.entry.options.name
+        return (
+          id === ns
+          || name === `@deepseek-ai/dsh-${ns}`
+          || name?.endsWith(`/${ns}`)
+          || (ns === 'llm-pi-ai' && (id === 'llm' || name === '@deepseek-ai/dsh-llm-pi-ai'))
+          || (ns === 'llm-deepseek' && (id === 'llm-deepseek-api-key' || name === '@deepseek-ai/dsh-llm-deepseek-api-key'))
+        )
+      })
+      if (match !== undefined) {
+        if (match.entry.fiber?.config !== undefined) {
+          return unwrapVolatiles(match.entry.fiber.config)
+        }
+        return unwrapVolatiles(deepMerge(match.inherited, match.override))
+      }
+    }
   } catch {
     return undefined
   }
+  return undefined
 }
 
 export class UsageService {
@@ -206,10 +316,10 @@ export class UsageService {
         // THIS route's account: it is supported by the adapter but not
         // applicable here, and the UI renders it as unsupported rather than
         // showing the other account's number (issue #1688).
-        ...(adapter?.balance !== undefined && balanceAppliesToRoute(adapter, this.piAiProfile(route.id)?.baseURL)
+        ...(adapter?.balance !== undefined && balanceAppliesToRoute(adapter, this.routeBaseUrl(route.id))
           ? { balanceSupported: true }
           : {}),
-        ...(adapter?.balance !== undefined && !balanceAppliesToRoute(adapter, this.piAiProfile(route.id)?.baseURL)
+        ...(adapter?.balance !== undefined && !balanceAppliesToRoute(adapter, this.routeBaseUrl(route.id))
           ? { balanceSupported: false }
           : {}),
         ...(adapter?.plan !== undefined ? { planSupported: true } : {}),
@@ -240,6 +350,9 @@ export class UsageService {
           totals: range.totals,
           providers: range.providers,
         },
+        // Every retained day, not just the trend window: the day picker's
+        // option list reaches back to the oldest day retention still keeps.
+        availableDays: allKeys,
         all: {
           from: allKeys[0] ?? todayKey,
           to: allKeys[allKeys.length - 1] ?? todayKey,
@@ -283,8 +396,19 @@ export class UsageService {
     }
   }
 
+  /**
+   * One retained local day aggregated per provider and model, as the day
+   * route serves it. A day the ledger never held — pruned by retention, or
+   * simply without usage — reads as a zeroed day rather than an error, so a
+   * picker selection that aged out degrades to "no usage" instead of a broken
+   * panel. The route gates the key's shape before it gets here.
+   */
+  day(dateKey: string): UsageDayView {
+    return this.daySummary(dateKey)
+  }
+
   /** One local day aggregated per provider. */
-  private daySummary(dateKey: string): UsageOverviewView['usage']['today'] {
+  private daySummary(dateKey: string): UsageDayView {
     const day = this.ledger.days[dateKey] ?? {}
     const { totals, providers } = summarizeDays([day])
     return { date: dateKey, totals, providers }
@@ -587,7 +711,7 @@ export class UsageService {
     // account, and probing the official endpoint would print this account's
     // money under that route's name (issue #1688). Such a route reports the
     // balance as unsupported instead.
-    const balanceApplies = balanceAppliesToRoute(adapter, this.piAiProfile(route.id)?.baseURL)
+    const balanceApplies = balanceAppliesToRoute(adapter, this.routeBaseUrl(route.id))
     if (credential.key === undefined) {
       // Nothing to probe with (oauth grant, no credential): retained facts
       // would never refresh again, so the row resets to its credential
@@ -705,4 +829,15 @@ export class UsageService {
     return section?.apiKeyEnv ?? 'DEEPSEEK_API_KEY'
   }
 
+  /** The DeepSeek official adapter's configured baseURL. */
+  private deepseekBaseUrl(): string | undefined {
+    const section = readNamespace(this.ctx, 'llm-deepseek') as { baseURL?: string } | undefined
+    return section?.baseURL
+  }
+
+  /** The effective base URL for a provider route (pi-ai or deepseek). */
+  private routeBaseUrl(provider: string): string | undefined {
+    return this.piAiProfile(provider)?.baseURL ?? (isDeepSeekProviderRoute(provider) ? this.deepseekBaseUrl() : undefined)
+  }
+
 }

package/src/index.ts

@@ -4,7 +4,7 @@ import type { SettingsNamespace } from '@deepseek-ai/dsh-settings'
 import z from '@deepseek-ai/schemastery'
 import { mountOnce } from './mount-once.ts'
 import { UsageService, type UsageServiceOptions } from './host/usage-service.ts'
-import { makeUsageOverviewRoute, makeUsageRefreshRoute } from './host/routes.ts'
+import { makeUsageDayRoute, makeUsageOverviewRoute, makeUsageRefreshRoute } from './host/routes.ts'
 
 declare module '@deepseek-ai/cordis' {
   interface Events {
@@ -126,9 +126,9 @@ export const apply = mountOnce('@linxin666/dsh-usage', (ctx: Context, config?: U
   /** True while this activation has a start queued behind a predecessor's flush. */
   let queued = false
 
-  /** Register the service's two routes; the returned disposer unregisters them. */
+  /** Register the service's routes; the returned disposer unregisters them. */
   const mountRoutes = (next: UsageService): (() => void) => {
-    const disposers = [makeUsageOverviewRoute(ctx, next), makeUsageRefreshRoute(ctx, next)]
+    const disposers = [makeUsageOverviewRoute(ctx, next), makeUsageDayRoute(ctx, next), makeUsageRefreshRoute(ctx, next)]
       .map((route) => ctx.webServer.register(route))
     return () => {
       for (const dispose of disposers) {

package/lib/types/host/run-guarded.d.ts

@@ -1,39 +0,0 @@
-/**
- * Async-boundary guard shared by the plugin family's Host halves: every
- * fire-and-forget promise chain and callback the host runtime does not own
- * (route handlers, timers, event listeners, spawned work) funnels through
- * these helpers. The dsh host installs a process-level fail-loud guard that
- * turns ANY unhandled promise rejection into a whole-process exit — one
- * plugin's stray rejection would otherwise take every plugin down. These
- * helpers exist so that failure mode is structurally impossible in family
- * code: the rejection becomes a logged error at the plugin boundary instead.
- *
- * Complements the aggregate's shell isolation (packages/dsh-web-all): the
- * shell contains import/activation failures at boot; runGuarded contains
- * run-time failures after activation.
- * @module dsh-web-shared/host/run-guarded
- */
-/**
- * Run one async operation, logging (never propagating) a rejection. Use for
- * promises whose lifecycle the caller does not await: spawned work, retry
- * loops, background flushes. Returns the original promise so callers can
- * still chain when they want to.
- * @param promise - the work to shield; any thenable.
- * @param label - log prefix naming the work site.
- * @param log - error sink; defaults to console.error.
- * @returns the input promise (rejection already consumed).
- */
-export declare function runGuarded<T>(promise: PromiseLike<T>, label: string, log?: (error: unknown) => void): PromiseLike<T>;
-/**
- * Wrap one callback so every invocation is individually guarded: a rejection
- * inside one call is logged and swallowed instead of escaping into whatever
- * infrastructure invoked the callback (HTTP server, EventEmitter, interval).
- * Sync throws are caught identically; a returned promise is replaced by
- * `undefined` after guarding (callers that need the original rejection should
- * await inside their own try/catch instead).
- * @param label - log prefix naming the callback site.
- * @param handler - the work to guard.
- * @param log - error sink; defaults to console.error.
- * @returns a wrapped callback with the same parameter list.
- */
-export declare function guardedHandler<A extends unknown[]>(label: string, handler: (...args: A) => unknown, log?: (error: unknown) => void): (...args: A) => unknown;

package/src/host/run-guarded.ts

@@ -1,76 +0,0 @@
-// Generated by scripts/sync-shared.mjs from shared/host/run-guarded.ts. Do not edit this copy; edit the shared source and run "node scripts/sync-shared.mjs".
-/**
- * Async-boundary guard shared by the plugin family's Host halves: every
- * fire-and-forget promise chain and callback the host runtime does not own
- * (route handlers, timers, event listeners, spawned work) funnels through
- * these helpers. The dsh host installs a process-level fail-loud guard that
- * turns ANY unhandled promise rejection into a whole-process exit — one
- * plugin's stray rejection would otherwise take every plugin down. These
- * helpers exist so that failure mode is structurally impossible in family
- * code: the rejection becomes a logged error at the plugin boundary instead.
- *
- * Complements the aggregate's shell isolation (packages/dsh-web-all): the
- * shell contains import/activation failures at boot; runGuarded contains
- * run-time failures after activation.
- * @module dsh-web-shared/host/run-guarded
- */
-
-/** Format one failure line for logging. */
-function formatFailure(label: string, error: unknown): Error {
-  return new Error(`[${label}] unhandled async failure: ${error instanceof Error ? error.stack ?? error.message : String(error)}`)
-}
-
-/**
- * Run one async operation, logging (never propagating) a rejection. Use for
- * promises whose lifecycle the caller does not await: spawned work, retry
- * loops, background flushes. Returns the original promise so callers can
- * still chain when they want to.
- * @param promise - the work to shield; any thenable.
- * @param label - log prefix naming the work site.
- * @param log - error sink; defaults to console.error.
- * @returns the input promise (rejection already consumed).
- */
-export function runGuarded<T>(promise: PromiseLike<T>, label: string, log: (error: unknown) => void = console.error): PromiseLike<T> {
-  void Promise.resolve(promise).catch(error => {
-    log(formatFailure(label, error))
-  })
-  return promise
-}
-
-/**
- * Wrap one callback so every invocation is individually guarded: a rejection
- * inside one call is logged and swallowed instead of escaping into whatever
- * infrastructure invoked the callback (HTTP server, EventEmitter, interval).
- * Sync throws are caught identically; a returned promise is replaced by
- * `undefined` after guarding (callers that need the original rejection should
- * await inside their own try/catch instead).
- * @param label - log prefix naming the callback site.
- * @param handler - the work to guard.
- * @param log - error sink; defaults to console.error.
- * @returns a wrapped callback with the same parameter list.
- */
-export function guardedHandler<A extends unknown[]>(
-  label: string,
-  handler: (...args: A) => unknown,
-  log: (error: unknown) => void = console.error,
-): (...args: A) => unknown {
-  return (...args: A) => {
-    try {
-      const result = handler(...args)
-      if (isPromiseLike(result)) {
-        void Promise.resolve(result).catch(error => {
-          log(formatFailure(label, error))
-        })
-        return undefined
-      }
-      return result
-    } catch (error) {
-      log(formatFailure(label, error))
-      return undefined
-    }
-  }
-}
-
-function isPromiseLike(value: unknown): value is PromiseLike<unknown> {
-  return typeof value === 'object' && value !== null && typeof (value as PromiseLike<unknown>).then === 'function'
-}