@goodandready/dsh-usage-guard 0.1.14 → 0.1.16

package/lib/index.js

@@ -13,7 +13,7 @@
 import z from '@deepseek-ai/schemastery'
 
 import { patchRegistry } from './patch.js'
-import { telemetry } from './telemetry.js'
+import { telemetry, registerTelemetryRoute } from './telemetry.js'
 import { registerPluginUpdater } from './updater.js'
 import { complaint, damage, healed, usageOf } from './usage.js'
 
@@ -97,21 +97,8 @@ export function apply(ctx, config) {
         manifestUrl: new URL('../package.json', import.meta.url),
       }), 'dsh-usage-guard: plugin updater route')
 
-      wctx.effect(() => wctx.webServer.register({
-        kind: 'exact',
-        path: '/api/dsh-usage-guard/telemetry',
-        handler: async (req, res) => {
-          if (req.method === 'GET' || req.method === 'HEAD') {
-            res.writeHead(200, {
-              'content-type': 'application/json; charset=utf-8',
-              'cache-control': 'no-store',
-            })
-            res.end(req.method === 'HEAD' ? undefined : JSON.stringify(telemetry.getSnapshot()))
-            return
-          }
-          res.writeHead(405, { allow: 'GET, HEAD' })
-          res.end()
-        },
+      wctx.effect(() => registerTelemetryRoute(wctx, {
+        endpoint: '/api/dsh-usage-guard/telemetry',
       }), 'dsh-usage-guard: telemetry route')
     } catch (err) {
       const msg = `[dsh-usage-guard] failed to register routes on webServer: ${err?.message || err}`
@@ -169,8 +156,6 @@ export function apply(ctx, config) {
         badFields: bad,
         fixedTokenCount: fixedTokensCount,
         clamped: clampedAny,
-        provider: event?.provider ?? event?.data?.provider ?? 'unknown',
-        sample: found.usage,
       })
 
       if (live && live.report !== false) {

package/lib/telemetry.js

@@ -11,7 +11,7 @@ class UsageGuardTelemetry {
     this.recentIncidents = [];
   }
 
-  recordIncident({ turn = 0, step = 0, badFields = [], fixedTokenCount = 0, clamped = false, provider = 'unknown', sample = null, kind = 'malformed-usage', target = '' } = {}) {
+  recordIncident({ turn = 0, step = 0, badFields = [], fixedTokenCount = 0, clamped = false, kind = 'malformed-usage', target = '' } = {}) {
     this.rescuedEvents += 1;
     this.fixedTokens += Number(fixedTokenCount) || 0;
     if (clamped) {
@@ -26,8 +26,6 @@ class UsageGuardTelemetry {
       target: String(target || (Array.isArray(badFields) ? badFields.join(',') : '')),
       fields: Array.isArray(badFields) ? badFields : [],
       clamped: Boolean(clamped),
-      provider: typeof provider === 'string' ? provider : 'unknown',
-      sample: sample && typeof sample === 'object' ? JSON.stringify(sample).slice(0, 300) : null,
     };
 
     this.lastIncident = incident;
@@ -89,6 +87,100 @@ export function resetTelemetry() {
   telemetry.reset();
 }
 
+function header(request, name) {
+  const value = request?.headers?.[name.toLowerCase()];
+  return Array.isArray(value) ? value[0] : value;
+}
+
+function isLoopbackAddress(value) {
+  const address = String(value || '').toLowerCase().replace(/^[[\]]/g, '');
+  return address === 'localhost' || address === 'localhost.' || address === '::1'
+    || address.startsWith('127.')
+    || address.startsWith('::ffff:127.');
+}
+
+/** Reject cross-site and unauthenticated requests while allowing same-origin and local callers. */
+export function isTrustedSettingsRequest(request, options = {}) {
+  if (!request || typeof request !== 'object' || !request.headers) return false;
+
+  const secFetchSite = header(request, 'sec-fetch-site');
+  // Unconditionally reject cross-site requests
+  if (secFetchSite === 'cross-site') {
+    return false;
+  }
+
+  const host = header(request, 'x-forwarded-host') || header(request, 'host');
+  const origin = header(request, 'origin');
+  if (origin) {
+    try {
+      const url = new URL(origin);
+      if (host && url.host.toLowerCase() === host.toLowerCase()) {
+        return true;
+      }
+      if (isLoopbackAddress(url.hostname) && isLoopbackAddress(request?.socket?.remoteAddress)) {
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  const referer = header(request, 'referer');
+  if (referer) {
+    try {
+      const url = new URL(referer);
+      if (host && url.host.toLowerCase() === host.toLowerCase()) {
+        return true;
+      }
+      if (isLoopbackAddress(url.hostname) && isLoopbackAddress(request?.socket?.remoteAddress)) {
+        return true;
+      }
+      return false;
+    } catch {
+      return false;
+    }
+  }
+
+  // Check Bearer token or custom auth header
+  const expectedToken = options.expectedToken
+    || (typeof process !== 'undefined' ? (process.env?.DSH_AUTH_TOKEN || process.env?.DSH_TOKEN) : null);
+
+  const auth = header(request, 'authorization');
+  if (typeof auth === 'string' && auth.startsWith('Bearer ')) {
+    const bearer = auth.slice(7).trim();
+    if (expectedToken && bearer && bearer === expectedToken) {
+      return true;
+    }
+  }
+
+  const customAuth = header(request, 'x-dsh-auth');
+  if (expectedToken && customAuth && customAuth === expectedToken) {
+    return true;
+  }
+
+  // Check cookie authentication
+  const cookie = header(request, 'cookie');
+  if (typeof cookie === 'string' && expectedToken) {
+    const match = cookie.match(/(?:^|;\s*)(?:token|dsh-auth|dsh_token)=([^;]+)/);
+    if (match && match[1] === expectedToken) {
+      return true;
+    }
+  }
+
+  // Same-origin or same-site fetch
+  if (secFetchSite === 'same-origin' || secFetchSite === 'same-site') {
+    return true;
+  }
+
+  // Loopback connection (curl, local process)
+  if (isLoopbackAddress(request?.socket?.remoteAddress)) {
+    return true;
+  }
+
+  return false;
+}
+
 export function registerTelemetryRoute(ctx, options = {}) {
   const endpoint = options.endpoint || '/api/dsh-usage-guard/telemetry';
   return ctx.webServer.register({
@@ -100,6 +192,14 @@ export function registerTelemetryRoute(ctx, options = {}) {
         response.end();
         return;
       }
+      if (!isTrustedSettingsRequest(request, options)) {
+        response.writeHead(403, {
+          'content-type': 'application/json; charset=utf-8',
+          'cache-control': 'no-store',
+        });
+        response.end(request.method === 'HEAD' ? undefined : JSON.stringify({ error: 'Forbidden: untrusted or cross-site request' }));
+        return;
+      }
       const snapshot = telemetry.getSnapshot();
       response.writeHead(200, {
         'content-type': 'application/json; charset=utf-8',

package/lib/updater.js

@@ -2,7 +2,7 @@
 // Implements canonical DSH plugin-updater specification.
 
 import { spawn } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
 import { readFile } from 'node:fs/promises';
 import { homedir } from 'node:os';
 import { basename, dirname, isAbsolute, resolve } from 'node:path';
@@ -55,11 +55,16 @@ function profileNameFromArgv(argv) {
   return argv[2] === 'web' ? 'web' : undefined;
 }
 
-function findDshCliEntry() {
-  const value = process.argv[1];
+export function findDshCliEntry(argv1 = process.argv[1]) {
+  const value = argv1;
   if (value === undefined || value === '') return undefined;
-  const entry = value.startsWith('file:') ? fileURLToPath(value) : resolve(process.cwd(), value);
+  let entry = value.startsWith('file:') ? fileURLToPath(value) : resolve(process.cwd(), value);
   if (!existsSync(entry)) return undefined;
+  try {
+    entry = realpathSync(entry);
+  } catch {
+    // Ignore symlink resolution errors and continue with unresolved path
+  }
   for (let directory = dirname(entry); ; directory = dirname(directory)) {
     const manifestPath = resolve(directory, 'package.json');
     if (existsSync(manifestPath)) {

package/lib/usage.js

@@ -102,10 +102,32 @@ export function usageOf(event) {
  * and the harness automatically defaults them to zero. We only flag values that actually
  * break arithmetic operations — missing required counters, non-numbers, non-integers, or negatives.
  */
+const clampedMap = new WeakMap()
+
+export function clampedDetails(usageOrBad, options = {}) {
+  if (Array.isArray(usageOrBad)) {
+    return clampedMap.get(usageOrBad) ?? null
+  }
+  const usage = usageOrBad
+  if (!usage || typeof usage !== 'object') return null
+  const maxStepTokens = typeof options === 'number' ? options : (Number(options?.maxStepTokens) > 0 ? Number(options.maxStepTokens) : 0)
+  if (maxStepTokens <= 0) return null
+  let clamped = null
+  for (const field of FIELDS) {
+    const value = usage[field]
+    if (typeof value === 'number' && Number.isFinite(value) && value > maxStepTokens) {
+      if (!clamped) clamped = {}
+      clamped[field] = { from: value, to: maxStepTokens }
+    }
+  }
+  return clamped
+}
+
 export function damage(usage, options = {}) {
   if (!usage || typeof usage !== 'object') return FIELDS.slice(0, 2)
   const bad = []
   const maxStepTokens = typeof options === 'number' ? options : (Number(options?.maxStepTokens) > 0 ? Number(options.maxStepTokens) : 0)
+  let clamped = null
 
   for (const field of FIELDS) {
     const value = usage[field]
@@ -115,10 +137,13 @@ export function damage(usage, options = {}) {
       bad.push(field)
     } else if (maxStepTokens > 0 && value > maxStepTokens) {
       bad.push(field)
-      bad.clamped = bad.clamped || {}
-      bad.clamped[field] = { from: value, to: maxStepTokens }
+      if (!clamped) clamped = {}
+      clamped[field] = { from: value, to: maxStepTokens }
     }
   }
+  if (clamped) {
+    clampedMap.set(bad, clamped)
+  }
   return bad
 }
 
@@ -129,30 +154,30 @@ export function damage(usage, options = {}) {
 export function borrowed(usage, field) {
   if (!usage || typeof usage !== 'object') return undefined
 
-  // 1. Search known alias names
+  // 1. Check the canonical field itself first if passed as a string or float (e.g. "123" or 15.4)
+  const selfNum = coerceNumber(usage[field])
+  if (selfNum !== undefined) return selfNum
+
+  // 2. Search known alias names
   for (const alias of ALIASES[field] ?? []) {
     const num = coerceNumber(usage[alias])
     if (num !== undefined) return num
   }
 
-  // 2. Search nested cache details (OpenAI-style: prompt_tokens_details.cached_tokens / cachedTokens)
+  // 3. Search nested cache details (OpenAI-style: prompt_tokens_details.cached_tokens / cachedTokens)
   if (field === 'cacheReadTokens' && usage.prompt_tokens_details && typeof usage.prompt_tokens_details === 'object') {
     const details = usage.prompt_tokens_details
     const num = coerceNumber(details.cached_tokens ?? details.cachedTokens ?? details.cache_read_tokens)
     if (num !== undefined) return num
   }
 
-  // 3. Search nested cache creation details (cache_creation_input_tokens)
+  // 4. Search nested cache creation details (cache_creation_input_tokens)
   if (field === 'cacheWriteTokens' && usage.prompt_tokens_details && typeof usage.prompt_tokens_details === 'object') {
     const details = usage.prompt_tokens_details
     const num = coerceNumber(details.cache_creation_tokens ?? details.cacheCreationTokens)
     if (num !== undefined) return num
   }
 
-  // 4. Check the field itself if passed as a string or float (e.g. "123" or 15.4)
-  const selfNum = coerceNumber(usage[field])
-  if (selfNum !== undefined) return selfNum
-
   return undefined
 }
 
@@ -223,12 +248,13 @@ export function complaint(found, bad, options = {}) {
   const taken = Array.isArray(bad)
     ? bad
         .map((field) => {
-          if (bad?.clamped?.[field]) {
-            return `${field} clamped abnormally large (${bad.clamped[field].from} -> ${bad.clamped[field].to})`
+          const clamped = options?.clamped ?? clampedMap.get(bad) ?? clampedDetails(usage, options)
+          if (clamped?.[field]) {
+            return `${field} clamped abnormally large (${clamped[field].from} -> ${clamped[field].to})`
           }
           const val = usage?.[field]
           if (maxStepTokens > 0 && typeof val === 'number' && val > maxStepTokens) {
-            return `${field} clamped to ${maxStepTokens}`
+            return `${field} clamped abnormally large (${val} -> ${maxStepTokens})`
           }
           return usage && borrowed(usage, field) !== undefined ? `${field} recovered via alias` : `${field} zeroed`
         })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-usage-guard",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "Keeps a malformed token-usage sample from taking a whole session history down with it: a missing or non-numeric counter becomes zero before the harness adds it up, so the fold never yields NaN and already-broken sessions open again.",
   "keywords": [
     "deepseek-harness",