@hasna/logs 0.3.24 → 0.3.25

package/dist/server/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/logs",
-  "version": "0.3.24",
+  "version": "0.3.25",
   "description": "Log aggregation + browser script + headless page scanner + performance monitoring for AI agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -40,12 +40,13 @@
   "author": "Andrei Hasna <andrei@hasna.com>",
   "license": "Apache-2.0",
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@hasna/cloud": "0.1.24",
+    "@hasna/events": "^0.1.6",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "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,7 +54,6 @@
     "@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 — push logs, query, browse issues, perf snapshots",
+  "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",
@@ -10,13 +10,18 @@
     "./browser": "./dist/index.js"
   },
   "publishConfig": {
-    "access": "restricted",
+    "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
   "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": "MIT"
+  "license": "Apache-2.0"
 }

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 over stdio.")
+  expect(result.stdout).toContain("Start the @hasna/logs MCP server (stdio by default).")
   expect(result.stdout).not.toContain("Listening")
   expect(result.stderr.trim()).toBe("")
 })

package/src/cli/index.ts

@@ -1,4 +1,5 @@
 #!/usr/bin/env bun
+import { registerEventsCommands } from "@hasna/events/commander";
 import { Command } from "commander"
 import { getDb } from "../db/index.ts"
 import { ingestLog } from "../lib/ingest.ts"
@@ -465,5 +466,6 @@ function parseRelativeTime(val?: string): string | undefined {
   const ms = Number(n) * (unit === "h" ? 3600 : unit === "d" ? 86400 : 60) * 1000
   return new Date(Date.now() - ms).toISOString()
 }
+registerEventsCommands(program, { source: "logs" });
 
 program.parse()

package/src/db/index.ts

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

package/src/lib/ingest.ts

@@ -1,4 +1,4 @@
-import type { Database as DbAdapter } from "bun:sqlite"
+import type { DbAdapter } from "@hasna/cloud"
 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 *
   `)
-  // Bun returns a callable transaction wrapper; invoke it to execute the batch.
+  // @hasna/cloud executes the callback inside the transaction immediately.
   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/mcp/http.test.ts

@@ -0,0 +1,92 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import { InMemoryTransport } from "@modelcontextprotocol/sdk/inMemory.js";
+import { buildServer } from "./index.ts";
+import {
+  DEFAULT_MCP_HTTP_PORT,
+  isHttpMode,
+  resolveMcpHttpPort,
+  startMcpHttpServer,
+} from "./http.ts";
+
+describe("logs MCP HTTP transport", () => {
+  test("defaults port to 8864", () => {
+    expect(DEFAULT_MCP_HTTP_PORT).toBe(8864);
+    expect(resolveMcpHttpPort(["node"], {})).toBe(8864);
+    expect(resolveMcpHttpPort(["node", "--port", "9001"], {})).toBe(9001);
+    expect(resolveMcpHttpPort(["node"], { MCP_HTTP_PORT: "9002" })).toBe(9002);
+  });
+
+  test("isHttpMode detects flag and env", () => {
+    expect(isHttpMode(["node"], {})).toBe(false);
+    expect(isHttpMode(["node", "--http"], {})).toBe(true);
+    expect(isHttpMode(["node"], { MCP_HTTP: "1" })).toBe(true);
+  });
+});
+
+describe("logs buildServer stdio registration", () => {
+  test("registers tools over in-memory transport", async () => {
+    const server = buildServer();
+    const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+    await server.connect(serverTransport);
+
+    const client = new Client({ name: "test", version: "0.0.0" });
+    await client.connect(clientTransport);
+
+    const tools = await client.listTools();
+    expect(tools.tools.some((tool) => tool.name === "get_health")).toBe(true);
+
+    await client.close();
+    await server.close();
+  });
+});
+
+describe("logs streamable HTTP server", () => {
+  let handle: Awaited<ReturnType<typeof startMcpHttpServer>>;
+
+  beforeAll(async () => {
+    handle = await startMcpHttpServer(buildServer, { port: 0 });
+  });
+
+  afterAll(async () => {
+    await handle.close();
+  });
+
+  test("GET /health returns ok", async () => {
+    const res = await fetch(`http://${handle.host}:${handle.port}/health`);
+    expect(res.status).toBe(200);
+    expect(await res.json()).toEqual({ status: "ok", name: "logs" });
+  });
+
+  test("initialize and call get_health over streamable HTTP", async () => {
+    const transport = new StreamableHTTPClientTransport(
+      new URL(`http://${handle.host}:${handle.port}/mcp`),
+    );
+    const client = new Client({ name: "test", version: "0.0.0" });
+    await client.connect(transport);
+
+    const result = await client.callTool({ name: "get_health", arguments: {} });
+    expect(result.content).toBeDefined();
+    expect(Array.isArray(result.content)).toBe(true);
+
+    await client.close();
+  });
+
+  test("serves three concurrent clients from one process", async () => {
+    const clients = await Promise.all(
+      Array.from({ length: 3 }, async () => {
+        const transport = new StreamableHTTPClientTransport(
+          new URL(`http://${handle.host}:${handle.port}/mcp`),
+        );
+        const client = new Client({ name: "test", version: "0.0.0" });
+        await client.connect(transport);
+        const tools = await client.listTools();
+        return { client, count: tools.tools.length };
+      }),
+    );
+
+    expect(clients.every((entry) => entry.count > 0)).toBe(true);
+    await Promise.all(clients.map((entry) => entry.client.close()));
+  });
+});

package/src/mcp/http.ts

@@ -0,0 +1,135 @@
+import { createServer, type IncomingMessage, type ServerResponse } from "node:http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+export const MCP_HTTP_SERVICE_NAME = "logs";
+export const DEFAULT_MCP_HTTP_PORT = 8864;
+
+export function isHttpMode(
+  argv: string[] = process.argv,
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  return argv.includes("--http") || env.MCP_HTTP === "1";
+}
+
+export function isStdioMode(
+  argv: string[] = process.argv,
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  return argv.includes("--stdio") || env.MCP_STDIO === "1";
+}
+
+export function resolveMcpHttpPort(
+  argv: string[] = process.argv,
+  env: NodeJS.ProcessEnv = process.env,
+): number {
+  const portIdx = argv.indexOf("--port");
+  if (portIdx !== -1 && argv[portIdx + 1]) {
+    return parsePort(argv[portIdx + 1]!, "--port");
+  }
+  if (env.MCP_HTTP_PORT) {
+    return parsePort(env.MCP_HTTP_PORT, "MCP_HTTP_PORT");
+  }
+  return DEFAULT_MCP_HTTP_PORT;
+}
+
+function parsePort(raw: string, source: string): number {
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 65535) {
+    throw new Error(`Invalid ${source} value "${raw}". Expected 0-65535.`);
+  }
+  return parsed;
+}
+
+async function readJsonBody(req: IncomingMessage): Promise<unknown> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  const text = Buffer.concat(chunks).toString("utf8");
+  if (!text) return undefined;
+  return JSON.parse(text) as unknown;
+}
+
+export type McpHttpServerHandle = {
+  port: number;
+  host: string;
+  close: () => Promise<void>;
+};
+
+export async function startMcpHttpServer(
+  buildServer: () => McpServer,
+  options?: { port?: number; host?: string; serviceName?: string },
+): Promise<McpHttpServerHandle> {
+  const host = options?.host ?? "127.0.0.1";
+  const requestedPort = options?.port ?? resolveMcpHttpPort();
+  const serviceName = options?.serviceName ?? MCP_HTTP_SERVICE_NAME;
+
+  const httpServer = createServer(async (req: IncomingMessage, res: ServerResponse) => {
+    try {
+      const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+
+      if (req.method === "GET" && url.pathname === "/health") {
+        res.writeHead(200, { "Content-Type": "application/json" });
+        res.end(JSON.stringify({ status: "ok", name: serviceName }));
+        return;
+      }
+
+      if (url.pathname !== "/mcp") {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not Found");
+        return;
+      }
+
+      const server = buildServer();
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+      });
+
+      await server.connect(transport);
+
+      let parsedBody: unknown;
+      if (req.method === "POST") {
+        parsedBody = await readJsonBody(req);
+      }
+
+      await transport.handleRequest(req, res, parsedBody);
+
+      res.on("close", () => {
+        void transport.close();
+        void server.close();
+      });
+    } catch (error) {
+      console.error(`[${serviceName}-mcp] HTTP error:`, error);
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json" });
+        res.end(
+          JSON.stringify({
+            jsonrpc: "2.0",
+            error: { code: -32603, message: "Internal server error" },
+            id: null,
+          }),
+        );
+      }
+    }
+  });
+
+  await new Promise<void>((resolve, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(requestedPort, host, () => resolve());
+  });
+
+  const addr = httpServer.address();
+  const port = typeof addr === "object" && addr ? addr.port : requestedPort;
+
+  console.error(`[${serviceName}-mcp] Streamable HTTP listening on http://${host}:${port}/mcp`);
+
+  return {
+    port,
+    host,
+    close: () =>
+      new Promise<void>((resolve, reject) => {
+        httpServer.close((err) => (err ? reject(err) : resolve()));
+      }),
+  };
+}

package/src/mcp/index.ts

@@ -1,6 +1,7 @@
 #!/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"
@@ -19,21 +20,26 @@ 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 over stdio.",
+  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)",
+  ],
 })
 
 const db = getDb()
-const server = new McpServer({ name: "logs", version: PACKAGE_VERSION })
 
-// --- in-memory agent registry ---
+// --- in-memory agent registry (module-level for shared HTTP process) ---
 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[] {
@@ -408,33 +414,31 @@ server.tool("list_agents", "List all registered agents.", {}, async () => {
   return { content: [{ type: "text" as const, text: JSON.stringify([..._logsAgents.values()]) }] }
 })
 
-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(() => {})
-  }
-})
+  registerCloudTools(server, "logs")
+  return server
+}
 
-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 })) }] }
-})
+async function main(): Promise<void> {
+  const { isStdioMode, resolveMcpHttpPort, startMcpHttpServer } = await import("./http.ts")
 
-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 })) }] }
-})
+  if (isStdioMode()) {
+    const server = buildServer()
+    const transport = new StdioServerTransport()
+    await server.connect(transport)
+    return
+  }
 
-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 })) }] }
-})
+  // Default: shared Streamable HTTP server (one process per MCP, many agents).
+  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)))
+}
 
-const transport = new StdioServerTransport()
-await server.connect(transport)
+if (import.meta.main) {
+  main().catch((err) => {
+    console.error(err)
+    process.exit(1)
+  })
+}