@hasna/logs 0.3.25 → 0.3.27

package/src/lib/ingest.test.ts

@@ -1,57 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { createTestDb } from "../db/index.ts"
-import { ingestBatch, ingestLog } from "./ingest.ts"
-
-describe("ingest", () => {
-  it("inserts a single log entry", () => {
-    const db = createTestDb()
-    const row = ingestLog(db, { level: "error", message: "test error", service: "api" })
-    expect(row.id).toBeTruthy()
-    expect(row.level).toBe("error")
-    expect(row.message).toBe("test error")
-    expect(row.service).toBe("api")
-    expect(row.source).toBe("sdk")
-    expect(row.timestamp).toBeTruthy()
-  })
-
-  it("inserts with all optional fields", () => {
-    const db = createTestDb()
-    const row = ingestLog(db, {
-      level: "info",
-      message: "hello",
-      source: "scanner",
-      trace_id: "trace-123",
-      session_id: "sess-456",
-      agent: "brutus",
-      url: "https://example.com",
-      stack_trace: "Error at line 1",
-      metadata: { foo: "bar" },
-    })
-    expect(row.trace_id).toBe("trace-123")
-    expect(row.agent).toBe("brutus")
-    expect(row.metadata).toBe(JSON.stringify({ foo: "bar" }))
-  })
-
-  it("inserts a batch", () => {
-    const db = createTestDb()
-    const rows = ingestBatch(db, [
-      { level: "warn", message: "warn 1" },
-      { level: "error", message: "err 1" },
-      { level: "info", message: "info 1" },
-    ])
-    expect(rows).toHaveLength(3)
-    expect(rows[0]!.level).toBe("warn")
-    expect(rows[2]!.level).toBe("info")
-  })
-
-  it("batch is transactional", () => {
-    const db = createTestDb()
-    const before = (db.prepare("SELECT COUNT(*) as c FROM logs").get() as { c: number }).c
-    ingestBatch(db, [
-      { level: "debug", message: "a" },
-      { level: "fatal", message: "b" },
-    ])
-    const after = (db.prepare("SELECT COUNT(*) as c FROM logs").get() as { c: number }).c
-    expect(after - before).toBe(2)
-  })
-})

package/src/lib/ingest.ts

@@ -1,78 +0,0 @@
-import type { DbAdapter } from "@hasna/cloud"
-import type { LogEntry, LogRow } from "../types/index.ts"
-import { upsertIssue } from "./issues.ts"
-import { evaluateAlerts } from "./alerts.ts"
-
-const ERROR_LEVELS = new Set(["warn", "error", "fatal"])
-
-export function ingestLog(db: DbAdapter, entry: LogEntry): LogRow {
-  const stmt = db.prepare(`
-    INSERT INTO logs (project_id, page_id, level, source, service, message, trace_id, session_id, agent, url, stack_trace, metadata)
-    VALUES ($project_id, $page_id, $level, $source, $service, $message, $trace_id, $session_id, $agent, $url, $stack_trace, $metadata)
-    RETURNING *
-  `)
-  const row = stmt.get({
-    $project_id: entry.project_id ?? null,
-    $page_id: entry.page_id ?? null,
-    $level: entry.level,
-    $source: entry.source ?? "sdk",
-    $service: entry.service ?? null,
-    $message: entry.message,
-    $trace_id: entry.trace_id ?? null,
-    $session_id: entry.session_id ?? null,
-    $agent: entry.agent ?? null,
-    $url: entry.url ?? null,
-    $stack_trace: entry.stack_trace ?? null,
-    $metadata: entry.metadata ? JSON.stringify(entry.metadata) : null,
-  }) as LogRow
-
-  // Side effects: issue grouping + alert evaluation (fire-and-forget)
-  if (ERROR_LEVELS.has(entry.level)) {
-    if (entry.project_id) {
-      upsertIssue(db, { project_id: entry.project_id, level: entry.level, service: entry.service, message: entry.message, stack_trace: entry.stack_trace })
-      evaluateAlerts(db, entry.project_id, entry.service ?? null, entry.level).catch(() => {})
-    }
-  }
-
-  return row
-}
-
-export function ingestBatch(db: DbAdapter, entries: LogEntry[], sharedTraceId?: string | null): LogRow[] {
-  // Apply shared trace_id to entries that don't have their own
-  if (sharedTraceId) {
-    entries = entries.map(e => e.trace_id ? e : { ...e, trace_id: sharedTraceId })
-  }
-  const insert = db.prepare(`
-    INSERT INTO logs (project_id, page_id, level, source, service, message, trace_id, session_id, agent, url, stack_trace, metadata)
-    VALUES ($project_id, $page_id, $level, $source, $service, $message, $trace_id, $session_id, $agent, $url, $stack_trace, $metadata)
-    RETURNING *
-  `)
-  // @hasna/cloud executes the callback inside the transaction immediately.
-  const rows = db.transaction(() =>
-    entries.map(entry =>
-      insert.get({
-        $project_id: entry.project_id ?? null,
-        $page_id: entry.page_id ?? null,
-        $level: entry.level,
-        $source: entry.source ?? "sdk",
-        $service: entry.service ?? null,
-        $message: entry.message,
-        $trace_id: entry.trace_id ?? null,
-        $session_id: entry.session_id ?? null,
-        $agent: entry.agent ?? null,
-        $url: entry.url ?? null,
-        $stack_trace: entry.stack_trace ?? null,
-        $metadata: entry.metadata ? JSON.stringify(entry.metadata) : null,
-      }) as LogRow
-    )
-  )
-
-  // Issue grouping for error-level entries (outside transaction for perf)
-  for (const entry of entries) {
-    if (ERROR_LEVELS.has(entry.level) && entry.project_id) {
-      upsertIssue(db, { project_id: entry.project_id, level: entry.level, service: entry.service, message: entry.message, stack_trace: entry.stack_trace })
-    }
-  }
-
-  return rows
-}

package/src/lib/issues.test.ts

@@ -1,79 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { createTestDb } from "../db/index.ts"
-import { computeFingerprint, getIssue, listIssues, updateIssueStatus, upsertIssue } from "./issues.ts"
-
-function seedProject(db: ReturnType<typeof createTestDb>) {
-  return db.prepare("INSERT INTO projects (name) VALUES ('app') RETURNING id").get() as { id: string }
-}
-
-describe("computeFingerprint", () => {
-  it("returns consistent hash for same input", () => {
-    const a = computeFingerprint("error", "api", "DB connection failed")
-    const b = computeFingerprint("error", "api", "DB connection failed")
-    expect(a).toBe(b)
-  })
-
-  it("returns different hash for different messages", () => {
-    const a = computeFingerprint("error", "api", "timeout")
-    const b = computeFingerprint("error", "api", "DB error")
-    expect(a).not.toBe(b)
-  })
-
-  it("normalizes hex IDs in messages", () => {
-    const a = computeFingerprint("error", "api", "Error for id abc123def456")
-    const b = computeFingerprint("error", "api", "Error for id 000fffaabbcc")
-    expect(a).toBe(b)
-  })
-})
-
-describe("upsertIssue", () => {
-  it("creates a new issue", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    const issue = upsertIssue(db, { project_id: p.id, level: "error", service: "api", message: "DB timeout" })
-    expect(issue.id).toBeTruthy()
-    expect(issue.count).toBe(1)
-    expect(issue.status).toBe("open")
-  })
-
-  it("increments count on duplicate", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    upsertIssue(db, { project_id: p.id, level: "error", message: "Same error" })
-    upsertIssue(db, { project_id: p.id, level: "error", message: "Same error" })
-    const issue = upsertIssue(db, { project_id: p.id, level: "error", message: "Same error" })
-    expect(issue.count).toBe(3)
-  })
-
-  it("reopens resolved issues", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    const issue = upsertIssue(db, { project_id: p.id, level: "error", message: "err" })
-    updateIssueStatus(db, issue.id, "resolved")
-    const reopened = upsertIssue(db, { project_id: p.id, level: "error", message: "err" })
-    expect(reopened.status).toBe("open")
-  })
-})
-
-describe("listIssues", () => {
-  it("filters by project and status", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    const issue = upsertIssue(db, { project_id: p.id, level: "error", message: "database connection timed out" })
-    updateIssueStatus(db, issue.id, "resolved")
-    upsertIssue(db, { project_id: p.id, level: "error", message: "authentication service unavailable" })
-    expect(listIssues(db, p.id, "open")).toHaveLength(1)
-    expect(listIssues(db, p.id, "resolved")).toHaveLength(1)
-    expect(listIssues(db, p.id)).toHaveLength(2)
-  })
-})
-
-describe("updateIssueStatus", () => {
-  it("updates status", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    const issue = upsertIssue(db, { project_id: p.id, level: "error", message: "x" })
-    const updated = updateIssueStatus(db, issue.id, "ignored")
-    expect(updated?.status).toBe("ignored")
-  })
-})

package/src/lib/issues.ts

@@ -1,70 +0,0 @@
-import type { Database } from "bun:sqlite"
-import { createHash } from "node:crypto"
-
-export interface Issue {
-  id: string
-  project_id: string | null
-  fingerprint: string
-  level: string
-  service: string | null
-  message_template: string
-  first_seen: string
-  last_seen: string
-  count: number
-  status: "open" | "resolved" | "ignored"
-}
-
-export function computeFingerprint(level: string, service: string | null, message: string, stackTrace?: string | null): string {
-  // Normalize message: strip hex IDs, numbers, timestamps
-  const normalized = message
-    .replace(/[0-9a-f]{8,}/gi, "<id>")
-    .replace(/\d+/g, "<n>")
-    .replace(/https?:\/\/[^\s]+/g, "<url>")
-    .trim()
-  const stackFrame = stackTrace ? stackTrace.split("\n").slice(0, 3).join("|") : ""
-  const raw = `${level}|${service ?? ""}|${normalized}|${stackFrame}`
-  return createHash("sha256").update(raw).digest("hex").slice(0, 16)
-}
-
-export function upsertIssue(db: Database, data: {
-  project_id?: string
-  level: string
-  service?: string | null
-  message: string
-  stack_trace?: string | null
-}): Issue {
-  const fingerprint = computeFingerprint(data.level, data.service ?? null, data.message, data.stack_trace)
-  return db.prepare(`
-    INSERT INTO issues (project_id, fingerprint, level, service, message_template)
-    VALUES ($project_id, $fingerprint, $level, $service, $message_template)
-    ON CONFLICT(project_id, fingerprint) DO UPDATE SET
-      count = count + 1,
-      last_seen = strftime('%Y-%m-%dT%H:%M:%fZ','now'),
-      status = CASE WHEN status = 'resolved' THEN 'open' ELSE status END
-    RETURNING *
-  `).get({
-    $project_id: data.project_id ?? null,
-    $fingerprint: fingerprint,
-    $level: data.level,
-    $service: data.service ?? null,
-    $message_template: data.message.slice(0, 500),
-  }) as Issue
-}
-
-export function listIssues(db: Database, projectId?: string, status?: string, limit = 50): Issue[] {
-  const conditions: string[] = []
-  const params: Record<string, unknown> = { $limit: limit }
-  if (projectId) { conditions.push("project_id = $p"); params.$p = projectId }
-  if (status) { conditions.push("status = $status"); params.$status = status }
-  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""
-  return db.prepare(`SELECT * FROM issues ${where} ORDER BY last_seen DESC LIMIT $limit`).all(params) as Issue[]
-}
-
-export function getIssue(db: Database, id: string): Issue | null {
-  return db.prepare("SELECT * FROM issues WHERE id = $id").get({ $id: id }) as Issue | null
-}
-
-export function updateIssueStatus(db: Database, id: string, status: "open" | "resolved" | "ignored"): Issue | null {
-  return db.prepare("UPDATE issues SET status = $status WHERE id = $id RETURNING *")
-    .get({ $id: id, $status: status }) as Issue | null
-}

package/src/lib/jobs.test.ts

@@ -1,69 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { createTestDb } from "../db/index.ts"
-import { createJob, createScanRun, deleteJob, finishScanRun, listJobs, listScanRuns, updateJob } from "./jobs.ts"
-
-function seedProject(db: ReturnType<typeof createTestDb>) {
-  return db.prepare("INSERT INTO projects (name) VALUES ('test') RETURNING id").get() as { id: string }
-}
-
-describe("jobs", () => {
-  it("creates a job", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    const job = createJob(db, { project_id: p.id, schedule: "*/5 * * * *" })
-    expect(job.id).toBeTruthy()
-    expect(job.schedule).toBe("*/5 * * * *")
-    expect(job.enabled).toBe(1)
-  })
-
-  it("lists jobs for a project", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    createJob(db, { project_id: p.id, schedule: "*/5 * * * *" })
-    createJob(db, { project_id: p.id, schedule: "*/10 * * * *" })
-    expect(listJobs(db, p.id)).toHaveLength(2)
-  })
-
-  it("updates a job", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    const job = createJob(db, { project_id: p.id, schedule: "*/5 * * * *" })
-    const updated = updateJob(db, job.id, { enabled: 0 })
-    expect(updated?.enabled).toBe(0)
-  })
-
-  it("deletes a job", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    const job = createJob(db, { project_id: p.id, schedule: "*/5 * * * *" })
-    deleteJob(db, job.id)
-    expect(listJobs(db, p.id)).toHaveLength(0)
-  })
-})
-
-describe("scan runs", () => {
-  it("creates and finishes a scan run", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    const job = createJob(db, { project_id: p.id, schedule: "*/5 * * * *" })
-    const run = createScanRun(db, { job_id: job.id })
-    expect(run.status).toBe("running")
-    expect(run.logs_collected).toBe(0)
-
-    const finished = finishScanRun(db, run.id, { status: "completed", logs_collected: 12, errors_found: 3, perf_score: 87.5 })
-    expect(finished?.status).toBe("completed")
-    expect(finished?.logs_collected).toBe(12)
-    expect(finished?.errors_found).toBe(3)
-    expect(finished?.perf_score).toBe(87.5)
-    expect(finished?.finished_at).toBeTruthy()
-  })
-
-  it("lists scan runs for a job", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    const job = createJob(db, { project_id: p.id, schedule: "*/5 * * * *" })
-    createScanRun(db, { job_id: job.id })
-    createScanRun(db, { job_id: job.id })
-    expect(listScanRuns(db, job.id)).toHaveLength(2)
-  })
-})

package/src/lib/jobs.ts

@@ -1,63 +0,0 @@
-import type { Database } from "bun:sqlite"
-import type { ScanJob, ScanRun } from "../types/index.ts"
-
-export function createJob(db: Database, data: { project_id: string; schedule: string; page_id?: string }): ScanJob {
-  return db.prepare(`
-    INSERT INTO scan_jobs (project_id, page_id, schedule)
-    VALUES ($project_id, $page_id, $schedule)
-    RETURNING *
-  `).get({
-    $project_id: data.project_id,
-    $page_id: data.page_id ?? null,
-    $schedule: data.schedule,
-  }) as ScanJob
-}
-
-export function listJobs(db: Database, projectId?: string): ScanJob[] {
-  if (projectId) {
-    return db.prepare("SELECT * FROM scan_jobs WHERE project_id = $p ORDER BY created_at DESC").all({ $p: projectId }) as ScanJob[]
-  }
-  return db.prepare("SELECT * FROM scan_jobs ORDER BY created_at DESC").all() as ScanJob[]
-}
-
-export function getJob(db: Database, id: string): ScanJob | null {
-  return db.prepare("SELECT * FROM scan_jobs WHERE id = $id").get({ $id: id }) as ScanJob | null
-}
-
-export function updateJob(db: Database, id: string, data: { enabled?: number; schedule?: string; last_run_at?: string }): ScanJob | null {
-  const fields = Object.keys(data).map(k => `${k} = $${k}`).join(", ")
-  if (!fields) return getJob(db, id)
-  const params = Object.fromEntries(Object.entries(data).map(([k, v]) => [`$${k}`, v]))
-  params.$id = id
-  return db.prepare(`UPDATE scan_jobs SET ${fields} WHERE id = $id RETURNING *`).get(params) as ScanJob | null
-}
-
-export function deleteJob(db: Database, id: string): void {
-  db.run("DELETE FROM scan_jobs WHERE id = $id", { $id: id })
-}
-
-export function createScanRun(db: Database, data: { job_id: string; page_id?: string }): ScanRun {
-  return db.prepare(`
-    INSERT INTO scan_runs (job_id, page_id) VALUES ($job_id, $page_id) RETURNING *
-  `).get({ $job_id: data.job_id, $page_id: data.page_id ?? null }) as ScanRun
-}
-
-export function finishScanRun(db: Database, id: string, data: { status: "completed" | "failed"; logs_collected: number; errors_found: number; perf_score?: number }): ScanRun | null {
-  return db.prepare(`
-    UPDATE scan_runs SET finished_at = strftime('%Y-%m-%dT%H:%M:%fZ','now'),
-      status = $status, logs_collected = $logs_collected,
-      errors_found = $errors_found, perf_score = $perf_score
-    WHERE id = $id RETURNING *
-  `).get({
-    $id: id,
-    $status: data.status,
-    $logs_collected: data.logs_collected,
-    $errors_found: data.errors_found,
-    $perf_score: data.perf_score ?? null,
-  }) as ScanRun | null
-}
-
-export function listScanRuns(db: Database, jobId: string, limit = 20): ScanRun[] {
-  return db.prepare("SELECT * FROM scan_runs WHERE job_id = $j ORDER BY started_at DESC LIMIT $l")
-    .all({ $j: jobId, $l: limit }) as ScanRun[]
-}

package/src/lib/lighthouse.ts

@@ -1,65 +0,0 @@
-import type { Database } from "bun:sqlite"
-import { saveSnapshot } from "./perf.ts"
-import type { PerformanceSnapshot } from "../types/index.ts"
-
-export interface LighthouseResult {
-  lcp: number | null
-  fcp: number | null
-  cls: number | null
-  tti: number | null
-  ttfb: number | null
-  score: number | null
-  raw_audit: string
-}
-
-export async function runLighthouse(url: string): Promise<LighthouseResult | null> {
-  try {
-    // Dynamic import — lighthouse is an optional peer dep
-    const { default: lighthouse } = await import("lighthouse" as string)
-    const { chromium } = await import("playwright")
-
-    const browser = await chromium.launch({ headless: true, args: ["--remote-debugging-port=9222"] })
-    try {
-      const result = await lighthouse(url, {
-        port: 9222,
-        output: "json",
-        logLevel: "silent",
-        onlyCategories: ["performance"],
-      } as Parameters<typeof lighthouse>[1])
-
-      if (!result) return null
-      const audits = result.lhr.audits
-      const score = result.lhr.categories["performance"]?.score
-
-      return {
-        lcp: (audits["largest-contentful-paint"]?.numericValue ?? null) as number | null,
-        fcp: (audits["first-contentful-paint"]?.numericValue ?? null) as number | null,
-        cls: (audits["cumulative-layout-shift"]?.numericValue ?? null) as number | null,
-        tti: (audits["interactive"]?.numericValue ?? null) as number | null,
-        ttfb: (audits["server-response-time"]?.numericValue ?? null) as number | null,
-        score: score !== undefined ? score * 100 : null,
-        raw_audit: JSON.stringify(result.lhr.audits),
-      }
-    } finally {
-      await browser.close()
-    }
-  } catch {
-    return null
-  }
-}
-
-export async function runAndSaveLighthouse(
-  db: Database,
-  url: string,
-  projectId: string,
-  pageId?: string,
-): Promise<PerformanceSnapshot | null> {
-  const result = await runLighthouse(url)
-  if (!result) return null
-  return saveSnapshot(db, {
-    project_id: projectId,
-    page_id: pageId ?? null,
-    url,
-    ...result,
-  })
-}

package/src/lib/package-meta.test.ts

@@ -1,43 +0,0 @@
-import { afterEach, expect, test } from "bun:test"
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs"
-import { tmpdir } from "node:os"
-import { join } from "node:path"
-import { pathToFileURL } from "node:url"
-import { readPackageVersion } from "./package-meta.ts"
-
-const tempRoots: string[] = []
-
-function createFixture() {
-  const root = mkdtempSync(join(tmpdir(), "logs-package-meta-"))
-  tempRoots.push(root)
-
-  mkdirSync(join(root, "src/lib"), { recursive: true })
-  mkdirSync(join(root, "dist"), { recursive: true })
-  writeFileSync(join(root, "package.json"), JSON.stringify({ version: "9.9.9" }), "utf8")
-
-  return root
-}
-
-afterEach(() => {
-  while (tempRoots.length > 0) {
-    const root = tempRoots.pop()
-    if (!root) continue
-    rmSync(root, { recursive: true, force: true })
-  }
-})
-
-test("readPackageVersion resolves package.json from source module paths", () => {
-  const root = createFixture()
-
-  const version = readPackageVersion(pathToFileURL(join(root, "src/lib/fake.js")))
-
-  expect(version).toBe("9.9.9")
-})
-
-test("readPackageVersion resolves package.json from bundled dist chunk paths", () => {
-  const root = createFixture()
-
-  const version = readPackageVersion(pathToFileURL(join(root, "dist/index-abc123.js")))
-
-  expect(version).toBe("9.9.9")
-})

package/src/lib/package-meta.ts

@@ -1,80 +0,0 @@
-import { existsSync, readFileSync } from "node:fs"
-
-type StandaloneCliSpec = {
-  name: string
-  description: string
-  options?: string[]
-}
-
-type PackageJson = {
-  version?: string
-}
-
-const PACKAGE_JSON_CANDIDATES = [
-  "../../package.json",
-  "../package.json",
-  "./package.json",
-]
-
-function readPackageJson(baseUrl: string | URL = import.meta.url): PackageJson {
-  // Bundled shared chunks live under dist/, while source modules live under src/lib/.
-  for (const relativePath of PACKAGE_JSON_CANDIDATES) {
-    const candidate = new URL(relativePath, baseUrl)
-    if (!existsSync(candidate)) continue
-
-    return JSON.parse(readFileSync(candidate, "utf8")) as PackageJson
-  }
-
-  throw new Error(`Unable to locate package.json from ${String(baseUrl)}`)
-}
-
-export function readPackageVersion(baseUrl: string | URL = import.meta.url): string {
-  return readPackageJson(baseUrl).version ?? "0.0.0"
-}
-
-export const PACKAGE_VERSION = readPackageVersion()
-
-export function exitIfMetadataRequest(spec: StandaloneCliSpec, argv = process.argv.slice(2)): void {
-  if (argv.includes("--version") || argv.includes("-V")) {
-    console.log(PACKAGE_VERSION)
-    process.exit(0)
-  }
-
-  if (argv.includes("--help") || argv.includes("-h")) {
-    const options = spec.options ?? []
-    const renderedOptions = [
-      "  -V, --version  output the version number",
-      "  -h, --help     display help for command",
-      ...options,
-    ]
-
-    console.log(
-      [
-        `Usage: ${spec.name} [options]`,
-        "",
-        spec.description,
-        "",
-        "Options:",
-        ...renderedOptions,
-      ].join("\n"),
-    )
-    process.exit(0)
-  }
-}
-
-export function readOptionValue(names: string[], argv = process.argv.slice(2)): string | undefined {
-  for (let index = 0; index < argv.length; index += 1) {
-    const arg = argv[index]
-    if (!arg) continue
-
-    const inline = names.find((name) => arg.startsWith(`${name}=`))
-    if (inline) return arg.slice(inline.length + 1)
-
-    if (names.includes(arg)) {
-      const next = argv[index + 1]
-      if (next && !next.startsWith("-")) return next
-    }
-  }
-
-  return undefined
-}

package/src/lib/page-auth.test.ts

@@ -1,54 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { createTestDb } from "../db/index.ts"
-import { deletePageAuth, getPageAuth, setPageAuth } from "./page-auth.ts"
-
-function seedPage(db: ReturnType<typeof createTestDb>) {
-  const p = db.prepare("INSERT INTO projects (name) VALUES ('app') RETURNING id").get() as { id: string }
-  const page = db.prepare("INSERT INTO pages (project_id, url) VALUES (?, 'https://app.com') RETURNING id").get(p.id) as { id: string }
-  return { projectId: p.id, pageId: page.id }
-}
-
-describe("page auth", () => {
-  it("sets and retrieves bearer auth", () => {
-    const db = createTestDb()
-    const { pageId } = seedPage(db)
-    setPageAuth(db, pageId, "bearer", "my-token-123")
-    const auth = getPageAuth(db, pageId)
-    expect(auth?.type).toBe("bearer")
-    expect(auth?.credentials).toBe("my-token-123")
-  })
-
-  it("credentials are encrypted at rest", () => {
-    const db = createTestDb()
-    const { pageId } = seedPage(db)
-    setPageAuth(db, pageId, "bearer", "secret-token")
-    const raw = db.prepare("SELECT credentials FROM page_auth WHERE page_id = ?").get(pageId) as { credentials: string }
-    // Raw value should NOT be the plaintext token
-    expect(raw.credentials).not.toBe("secret-token")
-    expect(raw.credentials).toContain(":")  // IV:encrypted format
-  })
-
-  it("upserts on duplicate page_id", () => {
-    const db = createTestDb()
-    const { pageId } = seedPage(db)
-    setPageAuth(db, pageId, "bearer", "token-v1")
-    setPageAuth(db, pageId, "bearer", "token-v2")
-    const auth = getPageAuth(db, pageId)
-    expect(auth?.credentials).toBe("token-v2")
-    const { c } = db.prepare("SELECT COUNT(*) as c FROM page_auth WHERE page_id = ?").get(pageId) as { c: number }
-    expect(c).toBe(1)
-  })
-
-  it("returns null for unknown page", () => {
-    const db = createTestDb()
-    expect(getPageAuth(db, "nope")).toBeNull()
-  })
-
-  it("deletes auth", () => {
-    const db = createTestDb()
-    const { pageId } = seedPage(db)
-    setPageAuth(db, pageId, "basic", "user:pass")
-    deletePageAuth(db, pageId)
-    expect(getPageAuth(db, pageId)).toBeNull()
-  })
-})