@hasna/logs 0.3.22 → 0.3.24

package/dist/server/index.js

@@ -6,7 +6,7 @@ import {
   setPageAuth,
   setRetentionPolicy,
   startScheduler
-} from "../index-ssqkc6nh.js";
+} from "../index-pf8hpweg.js";
 import {
   exportToCsv,
   exportToJson
@@ -37,7 +37,7 @@ import {
   updateAlertRule,
   updateIssueStatus,
   updateProject
-} from "../index-5cj74qka.js";
+} from "../index-g8f8kep6.js";
 import {
   createJob,
   deleteJob,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/logs",
-  "version": "0.3.22",
+  "version": "0.3.24",
   "description": "Log aggregation + browser script + headless page scanner + performance monitoring for AI agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -40,12 +40,12 @@
   "author": "Andrei Hasna <andrei@hasna.com>",
   "license": "Apache-2.0",
   "dependencies": {
-    "@hasna/cloud": "^0.1.24",
-    "@modelcontextprotocol/sdk": "^1.29.0",
+    "@modelcontextprotocol/sdk": "^1.12.1",
     "commander": "^14.0.0",
     "hono": "^4.7.11",
     "ink": "^5.1.0",
     "node-cron": "^3.0.3",
+    "pg": "^8.20.0",
     "playwright": "^1.52.0",
     "react": "^19.1.0"
   },
@@ -53,6 +53,7 @@
     "@biomejs/biome": "^1.9.4",
     "@types/bun": "latest",
     "@types/node-cron": "^3.0.11",
+    "@types/pg": "^8.20.0",
     "@types/react": "^19.1.4",
     "typescript": "^5.9.3"
   }

package/sdk/package.json

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

package/src/cli/entrypoints.test.ts

@@ -46,7 +46,7 @@ test("logs-mcp --help prints usage and exits without starting stdio transport",
 
   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).toContain("Start the @hasna/logs MCP server over stdio.")
   expect(result.stdout).not.toContain("Listening")
   expect(result.stderr.trim()).toBe("")
 })

package/src/db/index.ts

@@ -1,4 +1,4 @@
-import { SqliteAdapter as Database } from "@hasna/cloud"
+import { Database } from "bun:sqlite"
 import { join } from "node:path"
 import { existsSync, mkdirSync, cpSync } from "node:fs"
 import { migrateAlertRules } from "./migrations/001_alert_rules.ts"

package/src/lib/cloud-sync.ts

@@ -0,0 +1,167 @@
+import type { Database } from "bun:sqlite"
+import { getDb } from "../db/index.ts"
+import { PG_MIGRATIONS } from "../db/pg-migrations.ts"
+import { PgAdapterAsync } from "./remote-storage.ts"
+
+export const CLOUD_TABLES = [
+  "projects",
+  "pages",
+  "logs",
+  "scan_jobs",
+  "scan_runs",
+  "performance_snapshots",
+  "alert_rules",
+  "issues",
+  "page_auth",
+  "feedback",
+] as const
+
+type Row = Record<string, unknown>
+
+export function getCloudDatabaseUrl(): string | null {
+  return process.env.HASNA_LOGS_CLOUD_DATABASE_URL
+    ?? process.env.LOGS_CLOUD_DATABASE_URL
+    ?? null
+}
+
+export async function getCloudPg(): Promise<PgAdapterAsync> {
+  const url = getCloudDatabaseUrl()
+  if (!url) throw new Error("Missing HASNA_LOGS_CLOUD_DATABASE_URL or LOGS_CLOUD_DATABASE_URL")
+  return new PgAdapterAsync(url)
+}
+
+export async function runCloudMigrations(remote: PgAdapterAsync): Promise<void> {
+  for (const sql of PG_MIGRATIONS) await remote.run(sql)
+}
+
+export async function cloudPush(opts?: { tables?: string[] }): Promise<{ rows: number }> {
+  const remote = await getCloudPg()
+  try {
+    await runCloudMigrations(remote)
+    const db = getDb()
+    let rows = 0
+    for (const table of resolveTables(opts?.tables)) rows += await pushTable(db, remote, table)
+    return { rows }
+  } finally {
+    await remote.close()
+  }
+}
+
+export async function cloudPull(opts?: { tables?: string[] }): Promise<{ rows: number }> {
+  const remote = await getCloudPg()
+  try {
+    await runCloudMigrations(remote)
+    const db = getDb()
+    let rows = 0
+    for (const table of resolveTables(opts?.tables)) rows += await pullTable(remote, db, table)
+    return { rows }
+  } finally {
+    await remote.close()
+  }
+}
+
+export async function cloudSync(opts?: { tables?: string[] }): Promise<{ push: number; pull: number }> {
+  const push = await cloudPush(opts)
+  const pull = await cloudPull(opts)
+  return { push: push.rows, pull: pull.rows }
+}
+
+function resolveTables(tables?: string[]): string[] {
+  if (!tables || tables.length === 0) return [...CLOUD_TABLES]
+  const allowed = new Set<string>(CLOUD_TABLES)
+  const requested = tables.map(table => table.trim()).filter(Boolean)
+  const invalid = requested.filter(table => !allowed.has(table))
+  if (invalid.length > 0) throw new Error(`Unknown logs sync table(s): ${invalid.join(", ")}`)
+  return requested
+}
+
+function quoteIdent(identifier: string): string {
+  return `"${identifier.replace(/"/g, "\"\"")}"`
+}
+
+async function pushTable(db: Database, remote: PgAdapterAsync, table: string): Promise<number> {
+  const rows = db.query(`SELECT * FROM ${quoteIdent(table)}`).all() as Row[]
+  if (rows.length === 0) return 0
+  const columns = await filterRemoteColumns(remote, table, Object.keys(rows[0]!))
+  await upsertPg(remote, table, columns, rows)
+  return rows.length
+}
+
+async function pullTable(remote: PgAdapterAsync, db: Database, table: string): Promise<number> {
+  const rows = await remote.all(`SELECT * FROM ${quoteIdent(table)}`) as Row[]
+  if (rows.length === 0) return 0
+  const columns = filterLocalColumns(db, table, Object.keys(rows[0]!))
+  upsertSqlite(db, table, columns, rows)
+  return rows.length
+}
+
+async function filterRemoteColumns(remote: PgAdapterAsync, table: string, columns: string[]): Promise<string[]> {
+  const rows = await remote.all(`
+    SELECT column_name
+    FROM information_schema.columns
+    WHERE table_schema = 'public' AND table_name = ?
+  `, table) as Array<{ column_name: string }>
+  if (rows.length === 0) return columns
+  const allowed = new Set(rows.map(row => row.column_name))
+  return columns.filter(column => allowed.has(column))
+}
+
+function filterLocalColumns(db: Database, table: string, columns: string[]): string[] {
+  const rows = db.query(`PRAGMA table_info(${quoteIdent(table)})`).all() as Array<{ name: string }>
+  const allowed = new Set(rows.map(row => row.name))
+  return columns.filter(column => allowed.has(column))
+}
+
+async function upsertPg(remote: PgAdapterAsync, table: string, columns: string[], rows: Row[]): Promise<void> {
+  if (columns.length === 0) return
+  const columnList = columns.map(quoteIdent).join(", ")
+  const updateColumns = columns.filter(column => column !== "id")
+  const setClause = updateColumns.length > 0
+    ? updateColumns.map(column => `${quoteIdent(column)} = EXCLUDED.${quoteIdent(column)}`).join(", ")
+    : `${quoteIdent("id")} = EXCLUDED.${quoteIdent("id")}`
+
+  for (const row of rows) {
+    const placeholders = columns.map((_, index) => `$${index + 1}`).join(", ")
+    const params = columns.map(column => coerceForPg(table, column, row[column]))
+    await remote.run(
+      `INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES (${placeholders})
+       ON CONFLICT (${quoteIdent("id")}) DO UPDATE SET ${setClause}`,
+      ...params,
+    )
+  }
+}
+
+function upsertSqlite(db: Database, table: string, columns: string[], rows: Row[]): void {
+  if (columns.length === 0) return
+  const columnList = columns.map(quoteIdent).join(", ")
+  const placeholders = columns.map(() => "?").join(", ")
+  const updateColumns = columns.filter(column => column !== "id")
+  const setClause = updateColumns.length > 0
+    ? updateColumns.map(column => `${quoteIdent(column)} = excluded.${quoteIdent(column)}`).join(", ")
+    : `${quoteIdent("id")} = excluded.${quoteIdent("id")}`
+  const statement = db.prepare(
+    `INSERT INTO ${quoteIdent(table)} (${columnList}) VALUES (${placeholders})
+     ON CONFLICT (${quoteIdent("id")}) DO UPDATE SET ${setClause}`,
+  )
+  const insert = db.transaction((batch: Row[]) => {
+    for (const row of batch) statement.run(...columns.map(column => coerceForSqlite(row[column])))
+  })
+  insert(rows)
+}
+
+function coerceForPg(table: string, column: string, value: unknown): unknown {
+  if (value === undefined) return null
+  if ((table === "scan_jobs" || table === "alert_rules") && column === "enabled") {
+    return Boolean(value)
+  }
+  return value
+}
+
+function coerceForSqlite(value: unknown): string | number | bigint | boolean | null | Uint8Array {
+  if (value === undefined || value === null) return null
+  if (typeof value === "string" || typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return value
+  if (value instanceof Date) return value.toISOString()
+  if (Buffer.isBuffer(value) || value instanceof Uint8Array) return value
+  if (typeof value === "object") return JSON.stringify(value)
+  return String(value)
+}

package/src/lib/ingest.ts

@@ -1,4 +1,4 @@
-import type { DbAdapter } from "@hasna/cloud"
+import type { Database as DbAdapter } from "bun:sqlite"
 import type { LogEntry, LogRow } from "../types/index.ts"
 import { upsertIssue } from "./issues.ts"
 import { evaluateAlerts } from "./alerts.ts"
@@ -47,7 +47,7 @@ export function ingestBatch(db: DbAdapter, entries: LogEntry[], sharedTraceId?:
     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.
+  // Bun returns a callable transaction wrapper; invoke it to execute the batch.
   const rows = db.transaction(() =>
     entries.map(entry =>
       insert.get({
@@ -65,7 +65,7 @@ export function ingestBatch(db: DbAdapter, entries: LogEntry[], sharedTraceId?:
         $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) {

package/src/lib/remote-storage.ts

@@ -0,0 +1,45 @@
+import pg from "pg"
+import type { Pool } from "pg"
+
+function translatePlaceholders(sql: string): string {
+  let index = 0
+  return sql.replace(/\?/g, () => `$${++index}`)
+}
+
+function normalizeParams(params: unknown[]): unknown[] {
+  const flat = params.length === 1 && Array.isArray(params[0]) ? params[0] : params
+  return flat.map(value => value === undefined ? null : value)
+}
+
+function sslConfigFor(connectionString: string): { rejectUnauthorized: boolean } | undefined {
+  return connectionString.includes("sslmode=require") || connectionString.includes("ssl=true")
+    ? { rejectUnauthorized: false }
+    : undefined
+}
+
+export class PgAdapterAsync {
+  private readonly pool: Pool
+
+  constructor(connectionString: string) {
+    this.pool = new pg.Pool({ connectionString, ssl: sslConfigFor(connectionString) })
+  }
+
+  async run(sql: string, ...params: unknown[]): Promise<{ changes: number }> {
+    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params))
+    return { changes: result.rowCount ?? 0 }
+  }
+
+  async get(sql: string, ...params: unknown[]): Promise<unknown> {
+    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params))
+    return result.rows[0] ?? null
+  }
+
+  async all(sql: string, ...params: unknown[]): Promise<unknown[]> {
+    const result = await this.pool.query(translatePlaceholders(sql), normalizeParams(params))
+    return result.rows
+  }
+
+  async close(): Promise<void> {
+    await this.pool.end()
+  }
+}

package/src/mcp/index.ts

@@ -1,7 +1,6 @@
 #!/usr/bin/env bun
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
-import { registerCloudTools } from "@hasna/cloud"
 import { z } from "zod"
 import { getDb } from "../db/index.ts"
 import { exitIfMetadataRequest, PACKAGE_VERSION } from "../lib/package-meta.ts"
@@ -20,26 +19,21 @@ import { compare } from "../lib/compare.ts"
 import { getHealth } from "../lib/health.ts"
 import { getSessionContext } from "../lib/session-context.ts"
 import { parseTime } from "../lib/parse-time.ts"
+import { cloudPull, cloudPush, cloudSync, getCloudDatabaseUrl, getCloudPg } from "../lib/cloud-sync.ts"
 import type { LogLevel, LogRow } from "../types/index.ts"
 
 exitIfMetadataRequest({
   name: "logs-mcp",
-  description: "Start the @hasna/logs MCP server (stdio by default).",
-  options: [
-    "  --http           Serve MCP over Streamable HTTP (127.0.0.1)",
-    "  --port <number>  HTTP port (default: 8820, env: MCP_HTTP_PORT)",
-  ],
+  description: "Start the @hasna/logs MCP server over stdio.",
 })
 
 const db = getDb()
+const server = new McpServer({ name: "logs", version: PACKAGE_VERSION })
 
-// --- in-memory agent registry (module-level for shared HTTP process) ---
+// --- in-memory agent registry ---
 interface _LogsAgent { id: string; name: string; session_id?: string; last_seen_at: string; project_id?: string }
 const _logsAgents = new Map<string, _LogsAgent>()
 
-export function buildServer(): McpServer {
-  const server = new McpServer({ name: "logs", version: PACKAGE_VERSION })
-
 const BRIEF_FIELDS: (keyof LogRow)[] = ["id", "timestamp", "level", "message", "service"]
 
 function applyBrief(rows: LogRow[], brief = true): unknown[] {
@@ -414,30 +408,33 @@ server.tool("list_agents", "List all registered agents.", {}, async () => {
   return { content: [{ type: "text" as const, text: JSON.stringify([..._logsAgents.values()]) }] }
 })
 
-  registerCloudTools(server, "logs")
-  return server
-}
+server.tool("cloud_status", "Check configured logs PostgreSQL remote.", {}, async () => {
+  const url = getCloudDatabaseUrl()
+  if (!url) return { content: [{ type: "text" as const, text: "cloud: not configured" }] }
+  let cloud: Awaited<ReturnType<typeof getCloudPg>> | null = null
+  try {
+    cloud = await getCloudPg()
+    await cloud.get("SELECT 1 as ok")
+    const tables = await cloud.all("SELECT tablename FROM pg_tables WHERE schemaname = 'public' ORDER BY tablename") as Array<{ tablename: string }>
+    return { content: [{ type: "text" as const, text: JSON.stringify({ connected: true, tables: tables.map(row => row.tablename) }) }] }
+  } catch (error) {
+    return { content: [{ type: "text" as const, text: String(error) }], isError: true }
+  } finally {
+    if (cloud) await cloud.close().catch(() => {})
+  }
+})
 
-async function main(): Promise<void> {
-  const { isHttpMode, resolveMcpHttpPort, startMcpHttpServer } = await import("./http.ts")
+server.tool("cloud_push", "Push local logs data to PostgreSQL.", { tables: z.array(z.string()).optional() }, async ({ tables }) => {
+  return { content: [{ type: "text" as const, text: JSON.stringify(await cloudPush({ tables })) }] }
+})
 
-  if (isHttpMode()) {
-    const handle = await startMcpHttpServer(buildServer, {
-      port: resolveMcpHttpPort(),
-    })
-    process.on("SIGINT", () => void handle.close().finally(() => process.exit(0)))
-    process.on("SIGTERM", () => void handle.close().finally(() => process.exit(0)))
-    return
-  }
+server.tool("cloud_pull", "Pull logs data from PostgreSQL.", { tables: z.array(z.string()).optional() }, async ({ tables }) => {
+  return { content: [{ type: "text" as const, text: JSON.stringify(await cloudPull({ tables })) }] }
+})
 
-  const server = buildServer()
-  const transport = new StdioServerTransport()
-  await server.connect(transport)
-}
+server.tool("cloud_sync", "Push local logs data, then pull remote rows.", { tables: z.array(z.string()).optional() }, async ({ tables }) => {
+  return { content: [{ type: "text" as const, text: JSON.stringify(await cloudSync({ tables })) }] }
+})
 
-if (import.meta.main) {
-  main().catch((err) => {
-    console.error(err)
-    process.exit(1)
-  })
-}
+const transport = new StdioServerTransport()
+await server.connect(transport)