owlservable 0.2.1 → 0.2.3

package/auto.cjs

@@ -1,2 +1 @@
-// CJS wrapper — dynamic import works in CommonJS Node.js
-import('./index.js').then(function(m) { m.init() }).catch(function() {})
+require('./index.cjs').init()

package/index.cjs

@@ -0,0 +1,400 @@
+'use strict'
+const { EventEmitter } = require('node:events')
+const http  = require('node:http')
+const https = require('node:https')
+const fs    = require('node:fs')
+const path  = require('node:path')
+
+const __dir = __dirname
+
+const MAX_REQ_BODY = 32  * 1024
+const MAX_RES_BODY = 64  * 1024
+const MAX_PARSE    = 512 * 1024
+
+const emitter = new EventEmitter()
+emitter.setMaxListeners(100)
+
+const requests = []
+let nextId = 1
+
+function addRequest(entry) {
+  try {
+    const r = { id: nextId++, ...entry, timestamp: Date.now() }
+    requests.push(r)
+    if (requests.length > 500) requests.shift()
+    emitter.emit('request', r)
+    if (saveState.enabled) persistLine(r)
+    return r
+  } catch (_) {}
+}
+
+function updateRequest(id, patch) {
+  try {
+    const r = requests.find(r => r.id === id)
+    if (r) {
+      Object.assign(r, patch)
+      emitter.emit('update', { id, patch })
+      if (saveState.enabled && (patch.tokens || patch.resBody)) persistLine(r)
+    }
+  } catch (_) {}
+}
+
+function getRequests() { try { return requests.slice() } catch (_) { return [] } }
+
+function clearRequests() {
+  requests.splice(0)
+  if (saveState.enabled) try { fs.writeFileSync(saveState.filePath, '') } catch (_) {}
+  emitter.emit('reload', { requests: [], save: getSaveInfo() })
+}
+
+function extractAiMeta(body) {
+  try {
+    const j = JSON.parse(body)
+    if (j.usage?.total_tokens != null)
+      return { model: j.model || null, tokens: { input: j.usage.prompt_tokens || 0, output: j.usage.completion_tokens || 0, total: j.usage.total_tokens } }
+    if (j.usage?.input_tokens != null) {
+      const i = j.usage.input_tokens || 0, o = j.usage.output_tokens || 0
+      return { model: j.model || null, tokens: { input: i, output: o, total: i + o } }
+    }
+    if (j.usageMetadata?.totalTokenCount != null) {
+      const m = j.usageMetadata
+      return { model: j.modelVersion || null, tokens: { input: m.promptTokenCount || 0, output: m.candidatesTokenCount || 0, total: m.totalTokenCount } }
+    }
+    if (j.meta?.billed_units) {
+      const b = j.meta.billed_units, i = b.input_tokens || 0, o = b.output_tokens || 0
+      if (i || o) return { model: null, tokens: { input: i, output: o, total: i + o } }
+    }
+  } catch (_) {}
+  return null
+}
+
+function extractAiMetaFromSSE(raw) {
+  try {
+    let input = 0, output = 0, model = null
+    for (const line of raw.split('\n')) {
+      if (!line.startsWith('data: ') || line === 'data: [DONE]') continue
+      try {
+        const j = JSON.parse(line.slice(6))
+        if (j.usage?.total_tokens != null)
+          return { model: j.model || model, tokens: { input: j.usage.prompt_tokens || 0, output: j.usage.completion_tokens || 0, total: j.usage.total_tokens } }
+        if (j.type === 'message_start' && j.message) {
+          if (j.message.usage?.input_tokens) input = j.message.usage.input_tokens
+          if (j.message.model) model = j.message.model
+        }
+        if (j.type === 'message_delta' && j.usage?.output_tokens)
+          output = j.usage.output_tokens
+      } catch (_) {}
+    }
+    if (input || output) return { model, tokens: { input, output, total: input + output } }
+  } catch (_) {}
+  return null
+}
+
+function capStr(s, max) {
+  if (!s || typeof s !== 'string') return null
+  return s.length <= max ? s : s.slice(0, max) + '…'
+}
+
+function bodyFromInit(b) {
+  try {
+    if (typeof b === 'string')        return capStr(b, MAX_REQ_BODY)
+    if (b instanceof URLSearchParams) return capStr(b.toString(), MAX_REQ_BODY)
+    if (b instanceof ArrayBuffer)     return capStr(Buffer.from(b).toString('utf8'), MAX_REQ_BODY)
+    if (ArrayBuffer.isView(b))        return capStr(Buffer.from(b.buffer, b.byteOffset, b.byteLength).toString('utf8'), MAX_REQ_BODY)
+  } catch (_) {}
+  return null
+}
+
+let patched = false
+
+function handleJsonResponse(record, getText) {
+  getText()
+    .then(body => {
+      const meta   = extractAiMeta(body)
+      const update = { metaPending: false, resBody: capStr(body, MAX_RES_BODY) }
+      if (meta) Object.assign(update, meta)
+      updateRequest(record.id, update)
+    })
+    .catch(() => updateRequest(record.id, { metaPending: false }))
+}
+
+function handleSseResponse(record, getText) {
+  getText()
+    .then(body => {
+      const meta   = extractAiMetaFromSSE(body)
+      const update = { metaPending: false }
+      if (meta) Object.assign(update, meta)
+      updateRequest(record.id, update)
+    })
+    .catch(() => updateRequest(record.id, { metaPending: false }))
+}
+
+function patchFetch() {
+  const orig = globalThis.fetch
+  globalThis.fetch = async function interceptedFetch(input, init) {
+    let url = 'unknown', method = 'GET', reqBody = null
+    try {
+      url    = input instanceof Request ? input.url : String(input)
+      method = (init?.method || (input instanceof Request ? input.method : null) || 'GET').toUpperCase()
+      const rawBody = init?.body ?? null
+      if (typeof rawBody === 'string' && rawBody.includes('"stream"')) {
+        try {
+          const parsed = JSON.parse(rawBody)
+          if (parsed.stream === true && !parsed.stream_options?.include_usage) {
+            parsed.stream_options = { ...parsed.stream_options, include_usage: true }
+            init = { ...init, body: JSON.stringify(parsed) }
+          }
+        } catch (_) {}
+      }
+      reqBody = bodyFromInit(init?.body ?? null)
+    } catch (_) {}
+
+    const start = Date.now()
+    try {
+      const res    = await orig.call(this, input, init)
+      const ct     = res.headers.get('content-type') || ''
+      const isJson = ct.includes('application/json')
+      const isSse  = ct.includes('text/event-stream')
+      const r      = addRequest({ url, method, status: res.status, latency: Date.now() - start, reqBody, metaPending: isJson || isSse })
+      if (r && isJson) handleJsonResponse(r, () => res.clone().text())
+      if (r && isSse)  handleSseResponse(r,  () => res.clone().text())
+      return res
+    } catch (err) {
+      try { addRequest({ url, method, status: 0, latency: Date.now() - start, reqBody, error: err.message }) } catch (_) {}
+      throw err
+    }
+  }
+}
+
+function patchHttpModule(mod, protocol) {
+  const orig = mod.request
+  mod.request = function interceptedRequest(...args) {
+    const start = Date.now()
+    let url = 'unknown', method = 'GET'
+    try {
+      const first = args[0]
+      if (typeof first === 'string')               { url = first; method = args[1]?.method || 'GET' }
+      else if (first instanceof URL)               { url = first.toString(); method = args[1]?.method || 'GET' }
+      else if (first && typeof first === 'object') {
+        url    = `${protocol}://${first.hostname || first.host || 'localhost'}${first.port ? ':' + first.port : ''}${first.path || '/'}`
+        method = first.method || 'GET'
+      }
+    } catch (_) {}
+
+    const req = orig.apply(mod, args)
+    const reqChunks = []; let reqSize = 0
+    const origWrite = req.write
+    req.write = function(chunk, encoding, cb) {
+      try {
+        if (reqSize < MAX_REQ_BODY) {
+          const s = Buffer.isBuffer(chunk) ? chunk.toString('utf8') : typeof chunk === 'string' ? chunk : ''
+          if (s) { reqChunks.push(s); reqSize += s.length }
+        }
+      } catch (_) {}
+      return origWrite.call(this, chunk, encoding, cb)
+    }
+
+    try {
+      req.once('response', res => {
+        const reqBody = reqSize > 0 ? reqChunks.join('').slice(0, MAX_REQ_BODY) : null
+        const ct      = res.headers['content-type'] || ''
+        const isJson  = ct.includes('application/json')
+        const isSse   = ct.includes('text/event-stream')
+        const r       = addRequest({ url, method: method.toUpperCase(), status: res.statusCode, latency: Date.now() - start, reqBody, metaPending: isJson || isSse })
+        if (r && (isJson || isSse)) {
+          try {
+            const chunks = []; let size = 0
+            res.on('data', chunk => { try { if (size < MAX_PARSE) { chunks.push(chunk); size += chunk.length } } catch (_) {} })
+            const getText = () => new Promise((resolve, reject) => {
+              res.once('end',   () => { try { resolve(Buffer.concat(chunks).toString('utf8')) } catch (e) { reject(e) } })
+              res.once('error', reject)
+            })
+            if (isJson) handleJsonResponse(r, getText)
+            if (isSse)  handleSseResponse(r,  getText)
+          } catch (_) { updateRequest(r.id, { metaPending: false }) }
+        }
+      })
+      req.once('error', err => {
+        try { addRequest({ url, method: method.toUpperCase(), status: 0, latency: Date.now() - start, error: err.message }) } catch (_) {}
+      })
+    } catch (_) {}
+
+    return req
+  }
+}
+
+function patch() {
+  if (patched) return; patched = true
+  try { if (typeof globalThis.fetch === 'function') patchFetch() } catch (_) {}
+  try { patchHttpModule(http,  'http')  } catch (_) {}
+  try { patchHttpModule(https, 'https') } catch (_) {}
+}
+
+const saveState = { enabled: false, filePath: null, retention: null }
+
+function getSaveInfo() {
+  if (!saveState.enabled) return { enabled: false }
+  return { enabled: true, filePath: saveState.filePath, relPath: path.relative(process.cwd(), saveState.filePath).replace(/\\/g, '/'), retention: saveState.retention }
+}
+
+function persistLine(r) {
+  try { fs.appendFileSync(saveState.filePath, JSON.stringify(r) + '\n') } catch (_) {}
+}
+
+function parseLog(raw, cutoff) {
+  const byId = new Map()
+  for (const line of raw.split('\n')) {
+    try { const r = JSON.parse(line); if (r.id && r.timestamp > cutoff) byId.set(r.id, r) } catch (_) {}
+  }
+  return [...byId.values()].sort((a, b) => a.id - b.id)
+}
+
+function pruneFile() {
+  if (!saveState.filePath) return
+  try {
+    const raw = fs.readFileSync(saveState.filePath, 'utf8').trim()
+    if (!raw) return
+    const entries = parseLog(raw, Date.now() - saveState.retention)
+    const out = entries.map(JSON.stringify).join('\n')
+    fs.writeFileSync(saveState.filePath, out + (out ? '\n' : ''))
+  } catch (_) {}
+}
+
+function enableSave(retentionMs) {
+  const filePath = path.join(process.cwd(), '.owlservable', 'log.ndjson')
+  const dir      = path.dirname(filePath)
+  try { fs.mkdirSync(dir, { recursive: true }) } catch (_) {}
+  try { const gi = path.join(dir, '.gitignore'); if (!fs.existsSync(gi)) fs.writeFileSync(gi, '*\n') } catch (_) {}
+  try { fs.writeFileSync(path.join(dir, 'config.json'), JSON.stringify({ save: true, retention: retentionMs })) } catch (_) {}
+  saveState.enabled   = true
+  saveState.filePath  = filePath
+  saveState.retention = retentionMs
+  try {
+    const raw = fs.readFileSync(filePath, 'utf8').trim()
+    if (raw) {
+      const loaded = parseLog(raw, Date.now() - retentionMs)
+      for (const r of loaded) {
+        if (!requests.find(x => x.id === r.id)) requests.push(r)
+        if (r.id >= nextId) nextId = r.id + 1
+      }
+      if (requests.length > 500) requests.splice(0, requests.length - 500)
+    }
+  } catch (_) {}
+  pruneFile()
+  emitter.emit('reload', { requests: getRequests(), save: getSaveInfo() })
+}
+
+function disableSave() {
+  saveState.enabled = false
+  try { fs.unlinkSync(path.join(process.cwd(), '.owlservable', 'config.json')) } catch (_) {}
+  emitter.emit('saveConfig', getSaveInfo())
+}
+
+setInterval(() => { if (saveState.enabled) pruneFile() }, 3_600_000).unref()
+
+let server = null
+let DASHBOARD_HTML = null
+
+function getDashboard() {
+  if (!DASHBOARD_HTML) DASHBOARD_HTML = fs.readFileSync(path.join(__dir, 'dashboard.html'), 'utf8')
+  return DASHBOARD_HTML
+}
+
+function readBody(req) {
+  return new Promise((resolve, reject) => {
+    let body = ''
+    req.on('data', c => { body += c })
+    req.on('end', () => resolve(body))
+    req.on('error', reject)
+  })
+}
+
+function startDashboard(port) {
+  if (server) return
+
+  server = http.createServer((req, res) => {
+    try {
+      const urlPath = req.url?.split('?')[0] || '/'
+
+      if (urlPath === '/events') {
+        res.writeHead(200, { 'Content-Type': 'text/event-stream', 'Cache-Control': 'no-cache', 'Connection': 'keep-alive' })
+        const send = d => { try { res.write('data: ' + JSON.stringify(d) + '\n\n') } catch (_) {} }
+        send({ type: 'init', requests: getRequests(), save: getSaveInfo() })
+        const onReq    = r               => send({ type: 'request',    record: r })
+        const onUpdate = ({ id, patch }) => send({ type: 'update',     id, patch })
+        const onSave   = cfg             => send({ type: 'saveConfig', config: cfg })
+        const onReload = data            => send({ type: 'reload',     ...data })
+        emitter.on('request',    onReq)
+        emitter.on('update',     onUpdate)
+        emitter.on('saveConfig', onSave)
+        emitter.on('reload',     onReload)
+        req.on('close', () => {
+          emitter.off('request',    onReq)
+          emitter.off('update',     onUpdate)
+          emitter.off('saveConfig', onSave)
+          emitter.off('reload',     onReload)
+        })
+        return
+      }
+
+      if (urlPath === '/api/save' && req.method === 'POST') {
+        readBody(req).then(body => {
+          const { action, retention } = JSON.parse(body)
+          if (action === 'enable' && retention > 0) enableSave(retention)
+          else if (action === 'disable') disableSave()
+          res.writeHead(200, { 'Content-Type': 'application/json' })
+          res.end(JSON.stringify({ ok: true, save: getSaveInfo() }))
+        }).catch(e => { res.writeHead(400, { 'Content-Type': 'application/json' }); res.end(JSON.stringify({ error: e.message })) })
+        return
+      }
+
+      if (urlPath === '/api/clear' && req.method === 'POST') {
+        clearRequests()
+        res.writeHead(200, { 'Content-Type': 'application/json' })
+        res.end(JSON.stringify({ ok: true }))
+        return
+      }
+
+      if (urlPath === '/owl.png') {
+        try {
+          const data = fs.readFileSync(path.join(__dir, 'owl.png'))
+          res.writeHead(200, { 'Content-Type': 'image/png', 'Cache-Control': 'public, max-age=86400' })
+          res.end(data)
+        } catch (_) { res.writeHead(404); res.end() }
+        return
+      }
+
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' })
+      res.end(getDashboard())
+    } catch (_) { try { if (!res.headersSent) { res.writeHead(500); res.end() } } catch (_) {} }
+  })
+
+  server.on('error', e => { if (e.code === 'EADDRINUSE') console.warn('[owlservable] Port ' + port + ' in use — dashboard not started') })
+  server.listen(port, '127.0.0.1', () => console.log('[owlservable] Dashboard → http://localhost:' + port))
+}
+
+let initialized = false
+
+function init({ port = 4321, dashboard = true, logging = false, save = false, retention = 86_400_000 } = {}) {
+  if (initialized) return; initialized = true
+  if (process.env.NODE_ENV === 'production') {
+    console.warn('[owlservable] Refusing to start in NODE_ENV=production — remove owlservable from your production bundle')
+    return
+  }
+  try { patch() } catch (_) {}
+  if (!save) {
+    try {
+      const cfg = JSON.parse(fs.readFileSync(path.join(process.cwd(), '.owlservable', 'config.json'), 'utf8'))
+      if (cfg.save) { save = true; retention = cfg.retention || retention }
+    } catch (_) {}
+  }
+  if (save) try { enableSave(retention) } catch (_) {}
+  if (dashboard) try { startDashboard(port) } catch (_) {}
+  if (logging) {
+    emitter.on('request', r => {
+      try { console.log('[owlservable]', r.method, r.url, '→', r.status || r.error || '?', '(' + (r.latency || 0) + 'ms)') } catch (_) {}
+    })
+  }
+}
+
+module.exports = { init }

package/package.json

@@ -1,19 +1,25 @@
 {
   "name": "owlservable",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "Minimalist Observability Platform. Zero config, zero dependencies.",
   "type": "module",
   "main": "index.js",
   "types": "index.d.ts",
   "exports": {
-    ".": "./index.js",
+    ".": {
+      "types": "./index.d.ts",
+      "import": "./index.js",
+      "require": "./index.cjs"
+    },
     "./auto": {
+      "types": "./index.d.ts",
       "import": "./auto.js",
       "require": "./auto.cjs"
     }
   },
   "files": [
     "index.js",
+    "index.cjs",
     "index.d.ts",
     "auto.js",
     "auto.cjs",