@hasna/logs 0.3.25 → 0.3.27

package/sdk/package.json

@@ -1,27 +0,0 @@
-{
-  "name": "@hasna/logs-sdk",
-  "version": "0.1.0",
-  "description": "Zero-dependency fetch client for @hasna/logs \u2014 push logs, query, browse issues, perf snapshots",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": "./dist/index.js",
-    "./browser": "./dist/index.js"
-  },
-  "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org/"
-  },
-  "scripts": {
-    "build": "bun build src/index.ts --outdir dist --target browser"
-  },
-  "keywords": [
-    "logs",
-    "monitoring",
-    "sdk",
-    "ai-agents"
-  ],
-  "author": "Andrei Hasna <andrei@hasna.com>",
-  "license": "Apache-2.0"
-}

package/sdk/src/index.ts

@@ -1,143 +0,0 @@
-import type { LogEntry, LogLevel, LogQuery, LogRow, LogSummary, Page, PerformanceSnapshot, Project, ScanJob } from "./types.ts"
-
-export type { LogEntry, LogLevel, LogQuery, LogRow, LogSummary, Page, PerformanceSnapshot, Project, ScanJob }
-
-export interface LogsClientOptions {
-  url?: string
-  projectId?: string
-  apiKey?: string
-}
-
-const DEFAULT_URL = "http://localhost:3460"
-
-export class LogsClient {
-  private url: string
-  private projectId?: string
-  private headers: Record<string, string>
-
-  constructor(opts: LogsClientOptions = {}) {
-    this.url = (opts.url ?? DEFAULT_URL).replace(/\/$/, "")
-    this.projectId = opts.projectId
-    this.headers = { "Content-Type": "application/json" }
-    if (opts.apiKey) this.headers["Authorization"] = `Bearer ${opts.apiKey}`
-  }
-
-  async push(entry: LogEntry): Promise<LogRow> {
-    const res = await fetch(`${this.url}/api/logs`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify({ project_id: this.projectId, ...entry }),
-    })
-    return res.json() as Promise<LogRow>
-  }
-
-  async pushBatch(entries: LogEntry[]): Promise<{ inserted: number }> {
-    const res = await fetch(`${this.url}/api/logs`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify(entries.map(e => ({ project_id: this.projectId, ...e }))),
-    })
-    return res.json() as Promise<{ inserted: number }>
-  }
-
-  async search(query: LogQuery = {}): Promise<LogRow[]> {
-    const params = new URLSearchParams()
-    if (query.project_id ?? this.projectId) params.set("project_id", query.project_id ?? this.projectId!)
-    if (query.page_id) params.set("page_id", query.page_id)
-    if (query.level) params.set("level", Array.isArray(query.level) ? query.level.join(",") : query.level)
-    if (query.service) params.set("service", query.service)
-    if (query.since) params.set("since", query.since)
-    if (query.until) params.set("until", query.until)
-    if (query.text) params.set("text", query.text)
-    if (query.limit) params.set("limit", String(query.limit))
-    if (query.offset) params.set("offset", String(query.offset))
-    if (query.fields) params.set("fields", query.fields.join(","))
-    const res = await fetch(`${this.url}/api/logs?${params}`, { headers: this.headers })
-    return res.json() as Promise<LogRow[]>
-  }
-
-  async tail(projectId?: string, n = 50): Promise<LogRow[]> {
-    const params = new URLSearchParams({ n: String(n) })
-    const pid = projectId ?? this.projectId
-    if (pid) params.set("project_id", pid)
-    const res = await fetch(`${this.url}/api/logs/tail?${params}`, { headers: this.headers })
-    return res.json() as Promise<LogRow[]>
-  }
-
-  async summary(projectId?: string, since?: string): Promise<LogSummary[]> {
-    const params = new URLSearchParams()
-    const pid = projectId ?? this.projectId
-    if (pid) params.set("project_id", pid)
-    if (since) params.set("since", since)
-    const res = await fetch(`${this.url}/api/logs/summary?${params}`, { headers: this.headers })
-    return res.json() as Promise<LogSummary[]>
-  }
-
-  async context(traceId: string): Promise<LogRow[]> {
-    const res = await fetch(`${this.url}/api/logs/${traceId}/context`, { headers: this.headers })
-    return res.json() as Promise<LogRow[]>
-  }
-
-  async registerProject(name: string, githubRepo?: string, baseUrl?: string): Promise<Project> {
-    const res = await fetch(`${this.url}/api/projects`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify({ name, github_repo: githubRepo, base_url: baseUrl }),
-    })
-    return res.json() as Promise<Project>
-  }
-
-  async registerPage(projectId: string, url: string, path?: string, name?: string): Promise<Page> {
-    const res = await fetch(`${this.url}/api/projects/${projectId}/pages`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify({ url, path, name }),
-    })
-    return res.json() as Promise<Page>
-  }
-
-  async createScanJob(projectId: string, schedule: string, pageId?: string): Promise<ScanJob> {
-    const res = await fetch(`${this.url}/api/jobs`, {
-      method: "POST",
-      headers: this.headers,
-      body: JSON.stringify({ project_id: projectId, schedule, page_id: pageId }),
-    })
-    return res.json() as Promise<ScanJob>
-  }
-
-  async perfSnapshot(projectId: string, pageId?: string): Promise<PerformanceSnapshot | null> {
-    const params = new URLSearchParams({ project_id: projectId })
-    if (pageId) params.set("page_id", pageId)
-    const res = await fetch(`${this.url}/api/perf?${params}`, { headers: this.headers })
-    return res.json() as Promise<PerformanceSnapshot | null>
-  }
-
-  async perfTrend(projectId: string, pageId?: string, since?: string, limit?: number): Promise<PerformanceSnapshot[]> {
-    const params = new URLSearchParams({ project_id: projectId })
-    if (pageId) params.set("page_id", pageId)
-    if (since) params.set("since", since)
-    if (limit) params.set("limit", String(limit))
-    const res = await fetch(`${this.url}/api/perf/trend?${params}`, { headers: this.headers })
-    return res.json() as Promise<PerformanceSnapshot[]>
-  }
-}
-
-// Browser auto-capture init
-export function initLogs(opts: { projectId: string; url?: string }): void {
-  if (typeof window === "undefined") return
-  const serverUrl = (opts.url ?? DEFAULT_URL).replace(/\/$/, "")
-  const client = new LogsClient({ url: serverUrl, projectId: opts.projectId })
-  const q: LogEntry[] = []
-  const flush = () => { if (q.length) client.pushBatch(q.splice(0)).catch(() => {}) }
-  setInterval(flush, 2000)
-
-  const _ce = console.error.bind(console)
-  console.error = (...args: unknown[]) => { _ce(...args); q.push({ level: "error", message: args.map(String).join(" "), source: "script", url: location.href }) }
-
-  const _cw = console.warn.bind(console)
-  console.warn = (...args: unknown[]) => { _cw(...args); q.push({ level: "warn", message: args.map(String).join(" "), source: "script", url: location.href }) }
-
-  window.addEventListener("error", (e) => { q.push({ level: "error", message: e.message, stack_trace: e.error?.stack, source: "script", url: location.href }) })
-  window.addEventListener("unhandledrejection", (e) => { q.push({ level: "error", message: `Unhandled: ${e.reason?.message ?? e.reason}`, stack_trace: e.reason?.stack, source: "script", url: location.href }) })
-  window.addEventListener("beforeunload", flush)
-}

package/sdk/src/types.ts

@@ -1,56 +0,0 @@
-export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal"
-export type LogSource = "sdk" | "script" | "scanner"
-
-export interface LogEntry {
-  level: LogLevel
-  message: string
-  project_id?: string
-  page_id?: string
-  source?: LogSource
-  service?: string
-  trace_id?: string
-  session_id?: string
-  agent?: string
-  url?: string
-  stack_trace?: string
-  metadata?: Record<string, unknown>
-}
-
-export interface LogRow {
-  id: string; timestamp: string; project_id: string | null; page_id: string | null
-  level: LogLevel; source: LogSource; service: string | null; message: string
-  trace_id: string | null; session_id: string | null; agent: string | null
-  url: string | null; stack_trace: string | null; metadata: string | null
-}
-
-export interface Project {
-  id: string; name: string; github_repo: string | null; base_url: string | null
-  description: string | null; created_at: string
-}
-
-export interface Page {
-  id: string; project_id: string; url: string; path: string
-  name: string | null; last_scanned_at: string | null; created_at: string
-}
-
-export interface ScanJob {
-  id: string; project_id: string; page_id: string | null
-  schedule: string; enabled: number; last_run_at: string | null; created_at: string
-}
-
-export interface PerformanceSnapshot {
-  id: string; timestamp: string; project_id: string; page_id: string | null
-  url: string; lcp: number | null; fcp: number | null; cls: number | null
-  tti: number | null; ttfb: number | null; score: number | null; raw_audit: string | null
-}
-
-export interface LogQuery {
-  project_id?: string; page_id?: string; level?: LogLevel | LogLevel[]
-  service?: string; since?: string; until?: string; text?: string
-  trace_id?: string; limit?: number; offset?: number; fields?: string[]
-}
-
-export interface LogSummary {
-  project_id: string | null; service: string | null; page_id: string | null
-  level: LogLevel; count: number; latest: string
-}

package/src/cli/entrypoints.test.ts

@@ -1,63 +0,0 @@
-import { expect, test } from "bun:test"
-import { readFileSync } from "node:fs"
-import { fileURLToPath } from "node:url"
-
-const packageJson = JSON.parse(
-  readFileSync(new URL("../../package.json", import.meta.url), "utf8"),
-) as { version: string }
-
-async function runEntrypoint(entryRelativePath: string, args: string[]) {
-  const entry = fileURLToPath(new URL(entryRelativePath, import.meta.url))
-  const proc = Bun.spawn(["bun", entry, ...args], {
-    env: {
-      ...process.env,
-      LOGS_PORT: "0",
-    },
-    stdout: "pipe",
-    stderr: "pipe",
-  })
-
-  const timeout = new Promise<never>((_, reject) => {
-    const timer = setTimeout(() => {
-      proc.kill()
-      reject(new Error(`Timed out running ${entryRelativePath} ${args.join(" ")}`.trim()))
-    }, 2000)
-
-    proc.exited.finally(() => clearTimeout(timer))
-  })
-
-  const exitCode = await Promise.race([proc.exited, timeout])
-  const stdout = await new Response(proc.stdout).text()
-  const stderr = await new Response(proc.stderr).text()
-
-  return { exitCode, stdout, stderr }
-}
-
-test("logs --version matches package.json", async () => {
-  const result = await runEntrypoint("./index.ts", ["--version"])
-
-  expect(result.exitCode).toBe(0)
-  expect(result.stdout.trim()).toBe(packageJson.version)
-  expect(result.stderr.trim()).toBe("")
-})
-
-test("logs-mcp --help prints usage and exits without starting stdio transport", async () => {
-  const result = await runEntrypoint("../mcp/index.ts", ["--help"])
-
-  expect(result.exitCode).toBe(0)
-  expect(result.stdout).toContain("Usage: logs-mcp [options]")
-  expect(result.stdout).toContain("Start the @hasna/logs MCP server (stdio by default).")
-  expect(result.stdout).not.toContain("Listening")
-  expect(result.stderr.trim()).toBe("")
-})
-
-test("logs-serve --help prints usage and exits without starting the server", async () => {
-  const result = await runEntrypoint("../server/index.ts", ["--help"])
-
-  expect(result.exitCode).toBe(0)
-  expect(result.stdout).toContain("Usage: logs-serve [options]")
-  expect(result.stdout).toContain("Start the @hasna/logs REST API server.")
-  expect(result.stdout).not.toContain("server running")
-  expect(result.stdout).not.toContain("Scheduler started")
-  expect(result.stderr.trim()).toBe("")
-})