token-trace-manager 0.7.0

package/lib/daemon.mjs

@@ -0,0 +1,614 @@
+#!/usr/bin/env node
+// Daemon do token-trace-manager: proxy transparente + API local + dashboard.
+//
+// Regras de ouro:
+//  - Escuta APENAS em 127.0.0.1 (nunca exposto na rede).
+//  - Repassa headers de autenticação intactos; nunca guarda nem loga chaves.
+//  - Conteúdo de prompts/respostas só é gravado (em payloads/<id>.json) se
+//    storePayloads estiver ligado (default: ligado) — chaves de API nunca,
+//    em nenhuma hipótese, vão parar lá.
+//
+// Roteamento: http://127.0.0.1:PORT/{target}/{label?}/{caminho-upstream}
+//   target : chave em config.targets (anthropic, openai, gemini, ...)
+//   label  : segmento opcional estilo PROJ-123 para atribuir o custo
+//   resto  : caminho repassado ao targetUrl do provedor
+
+import fs from 'node:fs'
+import http from 'node:http'
+import https from 'node:https'
+import path from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { StringDecoder } from 'node:string_decoder'
+import { readConfig, pidFilePath, writeConfig, KNOWN_PROTOCOLS, validateConfig } from './config.mjs'
+import { insertUsageEvent, getKv, setKv, purgeExpired, deleteData, relabelUnlabeled, payloadPath } from './db.mjs'
+import { buildTraces } from './traces-data.mjs'
+import { createExtractor, SseParser, maybeInjectIncludeUsage, isUsageOnlyChunk } from './adapters.mjs'
+import { exportUsageEvent } from './otel-export.mjs'
+import { costBreakdown } from './pricing.mjs'
+import { buildReport } from './report-data.mjs'
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url))
+const VERSION = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'package.json'), 'utf8')).version
+
+// Label = qualquer identificador de tarefa: ticket real (PROJ-123) OU slug
+// descritivo (TCW-poc-proxy-contabilizacao-custo-ia) — não exige card já criado.
+// Exige AO MENOS UM hífen: é a assinatura que distingue um label de um
+// segmento normal de path do provedor (v1, v1beta, messages, models, ...),
+// nenhum dos quais tem hífen — sem isso o roteamento interpretaria "v1" como
+// label e quebraria toda chamada sem label explícito na URL.
+const LABEL_RE = /^[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)+$/
+const LABEL_MAX_LEN = 120
+const HOP_BY_HOP = new Set([
+  'connection',
+  'keep-alive',
+  'proxy-authenticate',
+  'proxy-authorization',
+  'te',
+  'trailer',
+  'transfer-encoding',
+  'upgrade',
+  'host',
+])
+const MAX_JSON_CAPTURE = 32 * 1024 * 1024
+
+const startedAt = Date.now()
+
+function sendJson(res, status, obj) {
+  const body = JSON.stringify(obj)
+  res.writeHead(status, { 'content-type': 'application/json', 'content-length': Buffer.byteLength(body) })
+  res.end(body)
+}
+
+function collectBody(req) {
+  return new Promise((resolve, reject) => {
+    const chunks = []
+    req.on('data', c => chunks.push(c))
+    req.on('end', () => resolve(Buffer.concat(chunks)))
+    req.on('error', reject)
+  })
+}
+
+async function handleLocal(req, res, pathname, searchParams) {
+  if (pathname === '/healthz') {
+    return sendJson(res, 200, {
+      ok: true,
+      version: VERSION,
+      uptime_s: Math.round((Date.now() - startedAt) / 1000),
+      pid: process.pid,
+    })
+  }
+
+  if (pathname === '/api/config') {
+    const cfg = readConfig()
+    return sendJson(res, 200, {
+      proxyUrl: cfg.proxyUrl,
+      port: cfg.port,
+      injectUsage: cfg.injectUsage,
+      targets: cfg.targets,
+      defaultLabel: await getKv('default_label'),
+    })
+  }
+
+  if (pathname === '/api/label') {
+    if (req.method === 'POST') {
+      const body = await collectBody(req)
+      let payload
+      try {
+        payload = JSON.parse(body.toString('utf8'))
+      } catch {
+        return sendJson(res, 400, {
+          error: 'JSON inválido; esperado {"label": "PROJ-123"|null, "context"?: {repo, branch}, "retroactiveMinutes"?: n}',
+        })
+      }
+      const label = payload.label ?? null
+      if (label !== null && (label.length > LABEL_MAX_LEN || !LABEL_RE.test(label))) {
+        return sendJson(res, 400, { error: `label "${label}" inválido (ex: PROJ-123 ou um-slug-descritivo, até ${LABEL_MAX_LEN} caracteres)` })
+      }
+      const normalized = label ? label.toUpperCase() : null
+      await setKv('default_label', normalized)
+
+      // Contexto do ambiente do agente (repo/branch, detectados pelo MCP) —
+      // carimbado em todo evento novo até ser trocado/limpo.
+      if ('context' in payload) {
+        const ctx = payload.context
+        await setKv(
+          'default_context',
+          ctx && (ctx.repo || ctx.branch)
+            ? JSON.stringify({ repo: ctx.repo ?? null, branch: ctx.branch ?? null })
+            : null,
+        )
+      }
+
+      // Retroativo: mensagens sem label da janela recebem a tarefa nova
+      // (caso "trabalhei antes de criar o card").
+      let relabeled = 0
+      if (normalized && payload.retroactiveMinutes > 0) {
+        const sinceIso = new Date(Date.now() - Math.min(payload.retroactiveMinutes, 24 * 60) * 60000).toISOString()
+        relabeled = (await relabelUnlabeled({ label: normalized, sinceIso })).relabeled
+      }
+
+      const ctxRaw = await getKv('default_context')
+      return sendJson(res, 200, {
+        defaultLabel: normalized,
+        context: ctxRaw ? JSON.parse(ctxRaw) : null,
+        relabeled,
+      })
+    }
+    const ctxRaw = await getKv('default_context')
+    return sendJson(res, 200, {
+      defaultLabel: await getKv('default_label'),
+      context: ctxRaw ? JSON.parse(ctxRaw) : null,
+    })
+  }
+
+  // labels são SEMPRE armazenados em maiúsculas — filtros idem, senão
+  // ?label=proj-123 devolve silenciosamente um relatório vazio
+  const labelParam = p => {
+    const v = p.get('label')
+    return v ? v.toUpperCase() : v
+  }
+
+  if (pathname === '/api/summary') {
+    const report = await buildReport({
+      since: searchParams.get('since'),
+      label: labelParam(searchParams),
+    })
+    return sendJson(res, 200, report)
+  }
+
+  if (pathname === '/api/traces') {
+    const traces = await buildTraces({
+      since: searchParams.get('since') || '24h',
+      label: labelParam(searchParams),
+      target: searchParams.get('target'),
+      model: searchParams.get('model'),
+      client: searchParams.get('client'),
+    })
+    return sendJson(res, 200, traces)
+  }
+
+  if (pathname === '/api/payload') {
+    const id = parseInt(searchParams.get('id') || '', 10)
+    if (!Number.isInteger(id) || id <= 0) return sendJson(res, 400, { error: 'id inválido' })
+    try {
+      const raw = fs.readFileSync(payloadPath(id), 'utf8')
+      res.writeHead(200, { 'content-type': 'application/json' })
+      return res.end(raw)
+    } catch {
+      return sendJson(res, 404, { error: 'sem payload para este evento (anterior ao armazenamento, desligado na config, ou expirado)' })
+    }
+  }
+
+  if (pathname === '/api/settings' && req.method === 'POST') {
+    const body = await collectBody(req)
+    let payload
+    try {
+      payload = JSON.parse(body.toString('utf8'))
+    } catch {
+      return sendJson(res, 400, { error: 'JSON inválido; esperado {"storePayloads": true|false}' })
+    }
+    if (typeof payload.storePayloads !== 'boolean') {
+      return sendJson(res, 400, { error: 'storePayloads deve ser booleano' })
+    }
+    writeConfig({ storePayloads: payload.storePayloads })
+    return sendJson(res, 200, { storePayloads: payload.storePayloads })
+  }
+
+  if (pathname === '/api/retention' && req.method === 'POST') {
+    const body = await collectBody(req)
+    let hours
+    try {
+      hours = JSON.parse(body.toString('utf8')).hours
+    } catch {
+      return sendJson(res, 400, { error: 'JSON inválido; esperado {"hours": 24} (0 = nunca apagar)' })
+    }
+    if (typeof hours !== 'number' || hours < 0 || hours > 24 * 365) {
+      return sendJson(res, 400, { error: 'hours deve ser um número entre 0 (nunca apagar) e 8760' })
+    }
+    writeConfig({ retentionHours: hours })
+    return sendJson(res, 200, { retentionHours: hours })
+  }
+
+  if (pathname === '/api/purge' && req.method === 'POST') {
+    const body = await collectBody(req)
+    let payload
+    try {
+      payload = JSON.parse(body.toString('utf8'))
+    } catch {
+      return sendJson(res, 400, { error: 'JSON inválido; esperado {"mode": "expired"|"events"|"everything", "label"?} ' })
+    }
+    if (payload.mode === 'expired') {
+      const cfg2 = readConfig()
+      if (!cfg2.retentionHours) return sendJson(res, 200, { purged: 0, note: 'retenção desligada (0)' })
+      const cutoff = new Date(Date.now() - cfg2.retentionHours * 3600000).toISOString()
+      return sendJson(res, 200, await purgeExpired(cutoff))
+    }
+    if (payload.mode === 'events' || payload.mode === 'everything') {
+      let label = payload.label ?? null
+      if (label !== null) {
+        if (label.length > LABEL_MAX_LEN || !LABEL_RE.test(label)) {
+          return sendJson(res, 400, { error: `label "${label}" inválido para deleção (ex: PROJ-123 ou um-slug-descritivo)` })
+        }
+        label = label.toUpperCase()
+      }
+      return sendJson(res, 200, await deleteData({ mode: payload.mode, label }))
+    }
+    return sendJson(res, 400, { error: 'mode deve ser expired | events | everything' })
+  }
+
+  if (pathname === '/api/events') {
+    const { listUsageEvents } = await import('./db.mjs')
+    const rows = await listUsageEvents({
+      since: searchParams.get('since'),
+      label: labelParam(searchParams),
+      limit: parseInt(searchParams.get('limit') || '100', 10),
+    })
+    return sendJson(res, 200, { events: rows })
+  }
+
+  // replacement como FUNÇÃO: um "$'" vindo de User-Agent/model no JSON seria
+  // interpretado como sequência especial de String.replace e corromperia o HTML
+  const servePage = (templateName, data) => {
+    const template = fs.readFileSync(path.join(__dirname, '..', 'templates', templateName), 'utf8')
+    const json = JSON.stringify(data).replace(/</g, '\\u003c')
+    res.writeHead(200, { 'content-type': 'text/html; charset=utf-8' })
+    res.end(template.replace('"__REPORT_DATA__"', () => json))
+  }
+
+  if (pathname === '/dashboard' || pathname === '/dashboard/') {
+    const report = await buildReport({ since: searchParams.get('since'), label: searchParams.get('label') })
+    return servePage('dashboard.html', report)
+  }
+
+  if (pathname === '/traces' || pathname === '/traces/') {
+    const traces = await buildTraces({
+      since: searchParams.get('since') || '24h',
+      label: labelParam(searchParams),
+      target: searchParams.get('target'),
+      model: searchParams.get('model'),
+      client: searchParams.get('client'),
+    })
+    return servePage('traces.html', traces)
+  }
+
+  if (pathname === '/config' || pathname === '/config/') {
+    const cfg2 = readConfig()
+    return servePage('config.html', {
+      port: cfg2.port,
+      retentionHours: cfg2.retentionHours,
+      storePayloads: cfg2.storePayloads,
+      injectUsage: cfg2.injectUsage,
+      otelOn: Boolean(cfg2.otel?.endpoint),
+      targets: cfg2.targets,
+      defaultLabel: await getKv('default_label'),
+      version: VERSION,
+    })
+  }
+
+  if (pathname === '/') {
+    res.writeHead(200, { 'content-type': 'text/plain; charset=utf-8' })
+    return res.end(
+      `token-trace-manager v${VERSION}\n\n` +
+        `Dashboard : /dashboard\n` +
+        `Health    : /healthz\n` +
+        `API       : /api/summary /api/events /api/label /api/config\n\n` +
+        `Uso como proxy: aponte a base URL do seu TUI para\n` +
+        `  http://127.0.0.1:${readConfig().port}/{target}[/{TICKET-123}]\n` +
+        `targets: ${Object.keys(readConfig().targets).join(', ')}\n`,
+    )
+  }
+
+  sendJson(res, 404, { error: 'rota não encontrada' })
+}
+
+async function proxyRequest(req, res, cfg, targetName, label, upstreamPath) {
+  const target = cfg.targets[targetName]
+
+  // Protocolo inválido (typo em target custom): falha cedo, sem fabricar
+  // evento de 0 tokens. readConfig marca _invalid; aqui é a defesa final.
+  if (target._invalid) {
+    return sendJson(res, 400, {
+      error: `target "${targetName}" tem protocolo inválido "${target.protocol}" (válidos: ${KNOWN_PROTOCOLS.join(', ')})`,
+    })
+  }
+
+  const started = Date.now()
+  const requestBody = await collectBody(req)
+
+  let outboundBody = requestBody
+  let weInjectedUsage = false
+  if (cfg.injectUsage) {
+    const injected = maybeInjectIncludeUsage(target.protocol, upstreamPath, requestBody)
+    if (injected) {
+      outboundBody = injected
+      weInjectedUsage = true
+    }
+  }
+
+  // Resolve o upstream: env-following (targetUrlEnv) tem precedência sobre
+  // targetUrl estática — permite "ttm segue meu redirect" sem reconfig.
+  let rawUrl
+  if (target.targetUrlEnv) {
+    rawUrl = process.env[target.targetUrlEnv]
+    if (!rawUrl) {
+      return sendJson(res, 502, { error: `target "${targetName}" exige env ${target.targetUrlEnv} (não setada no ambiente do daemon)` })
+    }
+  } else {
+    rawUrl = target.targetUrl
+  }
+  let upstreamUrl
+  try {
+    upstreamUrl = new URL(rawUrl)
+  } catch {
+    return sendJson(res, 502, { error: `targetUrl inválida para "${targetName}": ${rawUrl}` })
+  }
+  const basePath = upstreamUrl.pathname === '/' ? '' : upstreamUrl.pathname.replace(/\/$/, '')
+  const transport = upstreamUrl.protocol === 'http:' ? http : https
+
+  const headers = {}
+  for (const [k, v] of Object.entries(req.headers)) {
+    if (!HOP_BY_HOP.has(k)) headers[k] = v
+  }
+  headers.host = upstreamUrl.host
+  headers['accept-encoding'] = 'identity' // sem compressão pra podermos ler usage
+  if (outboundBody.length) headers['content-length'] = String(outboundBody.length)
+  else delete headers['content-length']
+
+  const finalLabel = label || (await getKv('default_label'))
+  let context = null
+  try {
+    const raw = await getKv('default_context')
+    if (raw) context = JSON.parse(raw)
+  } catch {
+    /* contexto corrompido — segue sem */
+  }
+  const extractor = createExtractor(target.protocol, { urlPath: upstreamPath })
+
+  const upstreamReq = transport.request(
+    {
+      hostname: upstreamUrl.hostname,
+      port: upstreamUrl.port || (upstreamUrl.protocol === 'http:' ? 80 : 443),
+      path: basePath + upstreamPath,
+      method: req.method,
+      headers,
+      timeout: 0,
+    },
+    upstreamRes => {
+      const isSse = /text\/event-stream/i.test(upstreamRes.headers['content-type'] || '')
+      const sse = isSse ? new SseParser((event, json) => extractor.onSse(event, json)) : null
+      const decoder = isSse ? new StringDecoder('utf8') : null
+      let jsonCapture = isSse ? null : []
+      let jsonCaptured = 0
+
+      // Quando NÓS injetamos include_usage, o chunk terminal de usage não
+      // pode vazar pro cliente — filtramos por evento SSE (UTF-8-safe).
+      const mustFilter = isSse && weInjectedUsage
+      let filterBuf = ''
+
+      const responseHeaders = {}
+      for (const [k, v] of Object.entries(upstreamRes.headers)) {
+        if (!HOP_BY_HOP.has(k)) responseHeaders[k] = v
+      }
+      if (mustFilter) delete responseHeaders['content-length'] // corpo pode encolher
+      res.writeHead(upstreamRes.statusCode, responseHeaders)
+
+      upstreamRes.on('data', chunk => {
+        let text = null
+        if (decoder) text = decoder.write(chunk)
+
+        if (mustFilter) {
+          filterBuf += text
+          let m
+          while ((m = /\r?\n\r?\n/.exec(filterBuf))) {
+            const rawEvent = filterBuf.slice(0, m.index)
+            const sep = m[0]
+            filterBuf = filterBuf.slice(m.index + sep.length)
+            if (!isUsageOnlyChunk(rawEvent)) res.write(Buffer.from(rawEvent + sep, 'utf8'))
+          }
+        } else {
+          res.write(chunk)
+        }
+
+        try {
+          if (sse) {
+            sse.feed(text)
+          } else if (jsonCapture && jsonCaptured < MAX_JSON_CAPTURE) {
+            jsonCapture.push(chunk)
+            jsonCaptured += chunk.length
+          }
+        } catch {
+          /* extração nunca pode derrubar o passthrough */
+        }
+      })
+
+      upstreamRes.on('end', () => {
+        if (mustFilter) {
+          const tail = filterBuf + (decoder ? decoder.end() : '')
+          if (tail && !isUsageOnlyChunk(tail)) res.write(Buffer.from(tail, 'utf8'))
+        }
+        res.end()
+        try {
+          if (jsonCapture) {
+            try {
+              extractor.onJsonBody(JSON.parse(Buffer.concat(jsonCapture).toString('utf8')))
+            } catch {
+              /* corpo não-JSON (ex: binário) — sem usage */
+            }
+          }
+          const u = extractor.result()
+          // sawUsage = campos reconhecidos presentes; usageUnknown = houve
+          // objeto usage mas nenhum campo bateu. Gravamos flagged (tokens 0)
+          // em vez de fantasma "completo" de 0 — fica visível que falhou.
+          if (u.sawUsage || u.usageUnknown) {
+            const { cost, rates } = costBreakdown(u.model, u)
+            const evRecord = {
+              label: finalLabel,
+              target: targetName,
+              protocol: target.protocol,
+              model: u.model,
+              providerId: u.providerId,
+              inputTokens: u.inputTokens,
+              cacheCreateTokens: u.cacheCreateTokens,
+              cacheCreate1hTokens: u.cacheCreate1hTokens,
+              cacheReadTokens: u.cacheReadTokens,
+              outputTokens: u.outputTokens,
+              reasoningTokens: u.reasoningTokens,
+              costUsd: cost,
+              rates,
+              usageFields: u.usageFields,
+              usageUnknown: u.usageUnknown,
+              repo: context?.repo ?? null,
+              branch: context?.branch ?? null,
+              status: upstreamRes.statusCode,
+              durationMs: Date.now() - started,
+              client: (req.headers['user-agent'] || '').slice(0, 120) || null,
+            }
+            const storePayloads = cfg.storePayloads
+            insertUsageEvent({ ...evRecord, payload: storePayloads })
+              .then(id => {
+                if (!storePayloads || !id) return
+                // Conteúdo da chamada para inspeção (segue a retenção; SEM
+                // headers — chaves de API nunca tocam o disco)
+                let request
+                if (requestBody.length > 4 * 1024 * 1024) {
+                  request = { _truncado: true, _bytes: requestBody.length }
+                } else {
+                  try {
+                    request = JSON.parse(requestBody.toString('utf8'))
+                  } catch {
+                    request = { _raw: requestBody.toString('utf8').slice(0, 1024 * 1024) }
+                  }
+                }
+                fs.writeFileSync(
+                  payloadPath(id),
+                  JSON.stringify({
+                    event_id: id,
+                    ts: evRecord.ts ?? new Date().toISOString(),
+                    label: evRecord.label,
+                    model: evRecord.model,
+                    request,
+                    response: { text: u.text || null },
+                  }),
+                )
+              })
+              .catch(err => process.stderr.write(`ttm: falha ao gravar evento/payload: ${err.message}\n`))
+            exportUsageEvent({ ...evRecord, ts: new Date().toISOString() }, cfg.otel)
+          }
+        } catch (err) {
+          process.stderr.write(`ttm: falha na extração de usage: ${err.message}\n`)
+        }
+      })
+
+      upstreamRes.on('error', () => {
+        try {
+          res.destroy()
+        } catch {
+          /* já encerrada */
+        }
+      })
+    },
+  )
+
+  upstreamReq.on('error', err => {
+    if (!res.headersSent) {
+      sendJson(res, 502, { error: `falha ao contatar ${target.targetUrl}: ${err.message}` })
+    } else {
+      res.destroy()
+    }
+  })
+
+  req.on('close', () => upstreamReq.destroy())
+  upstreamReq.end(outboundBody)
+}
+
+export function createDaemonServer() {
+  const server = http.createServer(async (req, res) => {
+    try {
+      const cfg = readConfig()
+      const parsed = new URL(req.url, 'http://localhost')
+      const segments = parsed.pathname.split('/').filter(Boolean)
+      const first = segments[0]
+
+      // Object.hasOwn (não `in`): /constructor etc. herdados do protótipo
+      // não podem virar target de proxy
+      if (!first || !Object.hasOwn(cfg.targets, first)) {
+        return await handleLocal(req, res, parsed.pathname, parsed.searchParams)
+      }
+
+      let label = null
+      let restIdx = 1
+      if (segments.length > 1 && LABEL_RE.test(segments[1])) {
+        label = segments[1].toUpperCase()
+        restIdx = 2
+      }
+      const upstreamPath = '/' + segments.slice(restIdx).join('/') + parsed.search
+      await proxyRequest(req, res, cfg, first, label, upstreamPath)
+    } catch (err) {
+      if (!res.headersSent) sendJson(res, 500, { error: err.message })
+      else res.destroy()
+    }
+  })
+  server.requestTimeout = 0 // respostas de LLM podem levar muitos minutos
+  server.headersTimeout = 60_000
+  return server
+}
+
+// Purge da retenção: ao expirar, agrega no histórico diário e apaga o trace.
+async function runRetentionPurge() {
+  try {
+    const cfg = readConfig()
+    if (!cfg.retentionHours) return // 0 = nunca apagar
+    const cutoff = new Date(Date.now() - cfg.retentionHours * 3600000).toISOString()
+    const { purged } = await purgeExpired(cutoff)
+    if (purged) process.stdout.write(`ttm: retenção — ${purged} trace(s) agregados no histórico e apagados\n`)
+  } catch (err) {
+    process.stderr.write(`ttm: purge de retenção falhou: ${err.message}\n`)
+  }
+}
+
+export function startDaemon() {
+  const cfg = readConfig()
+  const { warnings } = validateConfig(cfg)
+  for (const w of warnings) process.stderr.write(`ttm: ${w}\n`)
+  const server = createDaemonServer()
+  return new Promise((resolve, reject) => {
+    server.once('error', reject)
+    server.listen(cfg.port, '127.0.0.1', () => {
+      fs.writeFileSync(pidFilePath(), String(process.pid))
+      void runRetentionPurge()
+      const t = setInterval(runRetentionPurge, 3600000)
+      t.unref?.()
+      resolve({ server, port: cfg.port })
+    })
+  })
+}
+
+const invokedDirectly = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)
+if (invokedDirectly) {
+  startDaemon()
+    .then(({ port }) => {
+      process.stdout.write(`ttm daemon ouvindo em http://127.0.0.1:${port} (pid ${process.pid})\n`)
+      // Shutdown GRACIOSO: para de aceitar conexões novas mas deixa streams
+      // em voo terminarem (um restart de upgrade não pode cortar respostas
+      // de outros TUIs no meio). Força a saída após 15s se algo pendurar.
+      let shuttingDown = false
+      const shutdown = () => {
+        if (shuttingDown) return
+        shuttingDown = true
+        try {
+          fs.unlinkSync(pidFilePath())
+        } catch {
+          /* já removido */
+        }
+        server.close(() => process.exit(0))
+        const force = setTimeout(() => process.exit(0), 15_000)
+        force.unref?.()
+      }
+      process.on('SIGTERM', shutdown)
+      process.on('SIGINT', shutdown)
+    })
+    .catch(err => {
+      process.stderr.write(`ttm daemon: ${err.message}\n`)
+      process.exit(1)
+    })
+}