@hasna/logs 0.3.21 → 0.3.22

package/dist/query-7jwj05er.js

@@ -0,0 +1,15 @@
+// @bun
+import {
+  getLogContext,
+  getLogContextFromId,
+  searchLogs,
+  tailLogs
+} from "./index-ww5ggfv3.js";
+import"./index-997bkzr2.js";
+import"./index-re3ntm60.js";
+export {
+  tailLogs,
+  searchLogs,
+  getLogContextFromId,
+  getLogContext
+};

package/dist/server/index.js

@@ -6,7 +6,11 @@ import {
   setPageAuth,
   setRetentionPolicy,
   startScheduler
-} from "../index-4ba0sabv.js";
+} from "../index-ssqkc6nh.js";
+import {
+  exportToCsv,
+  exportToJson
+} from "../index-eh9bkbpa.js";
 import {
   getHealth
 } from "../index-cpvq9np9.js";
@@ -15,6 +19,7 @@ import {
   createPage,
   createProject,
   deleteAlertRule,
+  exitIfMetadataRequest,
   getDb,
   getIssue,
   getLatestSnapshot,
@@ -26,12 +31,13 @@ import {
   listIssues,
   listPages,
   listProjects,
+  readOptionValue,
   resolveProjectId,
   summarizeLogs,
   updateAlertRule,
   updateIssueStatus,
   updateProject
-} from "../index-vmr85wa1.js";
+} from "../index-5cj74qka.js";
 import {
   createJob,
   deleteJob,
@@ -49,10 +55,6 @@ import {
 import {
   parseTime
 } from "../index-997bkzr2.js";
-import {
-  exportToCsv,
-  exportToJson
-} from "../index-eh9bkbpa.js";
 import"../index-re3ntm60.js";
 
 // node_modules/hono/dist/compose.js
@@ -2442,7 +2444,13 @@ function streamRoutes(db) {
 }
 
 // src/server/index.ts
-var PORT = Number(process.env.LOGS_PORT ?? 3460);
+exitIfMetadataRequest({
+  name: "logs-serve",
+  description: "Start the @hasna/logs REST API server.",
+  options: ["  -p, --port <n>  Port to listen on (default: LOGS_PORT or 3460)"]
+});
+var portArg = readOptionValue(["--port", "-p"]);
+var PORT = Number(portArg ?? process.env.LOGS_PORT ?? 3460);
 var db = getDb();
 var app = new Hono2;
 app.use("*", cors());

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/logs",
-  "version": "0.3.21",
+  "version": "0.3.22",
   "description": "Log aggregation + browser script + headless page scanner + performance monitoring for AI agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -11,7 +11,7 @@
     "logs-serve": "./dist/server/index.js"
   },
   "scripts": {
-    "build": "bun build src/cli/index.ts src/mcp/index.ts src/server/index.ts --outdir dist --target bun --splitting --external playwright --external playwright-core --external electron --external chromium-bidi --external lighthouse",
+    "build": "bun build src/cli/index.ts src/mcp/index.ts src/server/index.ts src/index.ts --outdir dist --target bun --splitting --external playwright --external playwright-core --external electron --external chromium-bidi --external lighthouse",
     "build:dashboard": "cd dashboard && bun run build",
     "build:all": "bun run build:dashboard && bun run build",
     "dev": "bun run src/server/index.ts",
@@ -41,7 +41,7 @@
   "license": "Apache-2.0",
   "dependencies": {
     "@hasna/cloud": "^0.1.24",
-    "@modelcontextprotocol/sdk": "^1.12.1",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "commander": "^14.0.0",
     "hono": "^4.7.11",
     "ink": "^5.1.0",

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",
@@ -16,7 +16,12 @@
   "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/index.ts

@@ -0,0 +1 @@
+export * from "../sdk/src/index.ts";

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 8820", () => {
+    expect(DEFAULT_MCP_HTTP_PORT).toBe(8820);
+    expect(resolveMcpHttpPort(["node"], {})).toBe(8820);
+    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,128 @@
+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 = 8820;
+
+export function isHttpMode(
+  argv: string[] = process.argv,
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  return argv.includes("--http") || env.MCP_HTTP === "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

@@ -24,16 +24,22 @@ 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,6 +414,30 @@ server.tool("list_agents", "List all registered agents.", {}, async () => {
   return { content: [{ type: "text" as const, text: JSON.stringify([..._logsAgents.values()]) }] }
 })
 
-const transport = new StdioServerTransport()
-registerCloudTools(server, "logs")
-await server.connect(transport)
+  registerCloudTools(server, "logs")
+  return server
+}
+
+async function main(): Promise<void> {
+  const { isHttpMode, resolveMcpHttpPort, startMcpHttpServer } = await import("./http.ts")
+
+  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
+  }
+
+  const server = buildServer()
+  const transport = new StdioServerTransport()
+  await server.connect(transport)
+}
+
+if (import.meta.main) {
+  main().catch((err) => {
+    console.error(err)
+    process.exit(1)
+  })
+}