@hasna/brains 0.0.23 → 0.0.24

package/dist/mcp/http.d.ts

@@ -0,0 +1,16 @@
+import type { Server } from "@modelcontextprotocol/sdk/server/index.js";
+export declare const MCP_HTTP_SERVICE_NAME = "brains";
+export declare const DEFAULT_MCP_HTTP_PORT = 8801;
+export declare function isHttpMode(argv?: string[], env?: NodeJS.ProcessEnv): boolean;
+export declare function resolveMcpHttpPort(argv?: string[], env?: NodeJS.ProcessEnv): number;
+export type McpHttpServerHandle = {
+    port: number;
+    host: string;
+    close: () => Promise<void>;
+};
+export declare function startMcpHttpServer(buildServer: () => Server, options?: {
+    port?: number;
+    host?: string;
+    serviceName?: string;
+}): Promise<McpHttpServerHandle>;
+//# sourceMappingURL=http.d.ts.map

package/dist/mcp/http.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"http.d.ts","sourceRoot":"","sources":["../../src/mcp/http.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AAExE,eAAO,MAAM,qBAAqB,WAAW,CAAC;AAC9C,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAE1C,wBAAgB,UAAU,CACxB,IAAI,GAAE,MAAM,EAAiB,EAC7B,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,OAAO,CAET;AAED,wBAAgB,kBAAkB,CAChC,IAAI,GAAE,MAAM,EAAiB,EAC7B,GAAG,GAAE,MAAM,CAAC,UAAwB,GACnC,MAAM,CASR;AAoBD,MAAM,MAAM,mBAAmB,GAAG;IAChC,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC5B,CAAC;AAEF,wBAAsB,kBAAkB,CACtC,WAAW,EAAE,MAAM,MAAM,EACzB,OAAO,CAAC,EAAE;IAAE,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,GAC/D,OAAO,CAAC,mBAAmB,CAAC,CAwE9B"}

package/dist/mcp/index.d.ts

@@ -5,7 +5,7 @@ export declare const MCP_SERVER_INFO: {
     readonly name: "brains";
     readonly version: string;
 };
-export declare function createMcpServer(): Server<{
+export declare function buildServer(): Server<{
     method: string;
     params?: {
         [x: string]: unknown;
@@ -39,6 +39,8 @@ export declare function createMcpServer(): Server<{
         } | undefined;
     } | undefined;
 }>;
+/** @deprecated Use buildServer() */
+export declare const createMcpServer: typeof buildServer;
 export declare function startMcpServer(transport?: StdioServerTransport): Promise<Server<{
     method: string;
     params?: {

package/dist/mcp/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAqDjF,eAAO,MAAM,eAAe;;;CAGlB,CAAC;AAEX,wBAAgB,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6e9B;AAED,wBAAsB,cAAc,CAAC,SAAS,uBAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAW1E"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/mcp/index.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,MAAM,EAAE,MAAM,2CAA2C,CAAC;AACnE,OAAO,EAAE,oBAAoB,EAAE,MAAM,2CAA2C,CAAC;AAsDjF,eAAO,MAAM,eAAe;;;CAGlB,CAAC;AAEX,wBAAgB,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmf1B;AAED,oCAAoC;AACpC,eAAO,MAAM,eAAe,oBAAc,CAAC;AAqB3C,wBAAsB,cAAc,CAAC,SAAS,uBAA6B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAI1E"}

package/dist/mcp/index.js

@@ -24119,6 +24119,100 @@ var McpFinetuneStatusSchema = exports_external2.object({
   provider: ProviderSchema
 });
 
+// src/mcp/http.ts
+import { createServer } from "http";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+var MCP_HTTP_SERVICE_NAME = "brains";
+var DEFAULT_MCP_HTTP_PORT = 8801;
+function isHttpMode(argv = process.argv, env = process.env) {
+  return argv.includes("--http") || env.MCP_HTTP === "1";
+}
+function resolveMcpHttpPort(argv = process.argv, env = process.env) {
+  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, source) {
+  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) {
+  const chunks = [];
+  for await (const chunk of req) {
+    chunks.push(typeof chunk === "string" ? Buffer.from(chunk) : chunk);
+  }
+  const text2 = Buffer.concat(chunks).toString("utf8");
+  if (!text2)
+    return;
+  return JSON.parse(text2);
+}
+async function startMcpHttpServer(buildServer, options) {
+  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, res) => {
+    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;
+      if (req.method === "POST") {
+        parsedBody = await readJsonBody(req);
+      }
+      await transport.handleRequest(req, res, parsedBody);
+      res.on("close", () => {
+        transport.close();
+        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((resolve3, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(requestedPort, host, () => resolve3());
+  });
+  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((resolve3, reject) => {
+      httpServer.close((err) => err ? reject(err) : resolve3());
+    })
+  };
+}
+
 // src/mcp/index.ts
 function getProvider(provider) {
   if (provider === "openai")
@@ -24148,7 +24242,7 @@ var MCP_SERVER_INFO = {
   name: "brains",
   version: getPackageVersion()
 };
-function createMcpServer() {
+function buildServer() {
   const server = new Server(MCP_SERVER_INFO, { capabilities: { tools: {} } });
   server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
@@ -24573,21 +24667,65 @@ function createMcpServer() {
       };
     }
   });
-  return server;
-}
-async function startMcpServer(transport = new StdioServerTransport) {
-  const server = createMcpServer();
   try {
     registerCloudTools(server, "brains");
   } catch {}
+  return server;
+}
+var createMcpServer = buildServer;
+function hasFlag(...flags) {
+  return process.argv.some((arg) => flags.includes(arg));
+}
+function printHelp() {
+  process.stdout.write(`Usage: brains-mcp [options]
+
+Brains MCP server (stdio transport by default)
+
+Options:
+  --http           Serve MCP over Streamable HTTP (127.0.0.1)
+  --port <number>  HTTP port (default: 8801, env: MCP_HTTP_PORT)
+  -h, --help       Show help
+  -V, --version    Show version
+`);
+}
+async function startMcpServer(transport = new StdioServerTransport) {
+  const server = buildServer();
   await server.connect(transport);
   return server;
 }
-if (import.meta.main) {
+async function main() {
+  if (hasFlag("--help", "-h")) {
+    printHelp();
+    return;
+  }
+  if (hasFlag("--version", "-V")) {
+    process.stdout.write(`${MCP_SERVER_INFO.version}
+`);
+    return;
+  }
+  if (isHttpMode()) {
+    const handle = await startMcpHttpServer(buildServer, {
+      port: resolveMcpHttpPort()
+    });
+    process.on("SIGINT", () => {
+      handle.close().finally(() => process.exit(0));
+    });
+    process.on("SIGTERM", () => {
+      handle.close().finally(() => process.exit(0));
+    });
+    return;
+  }
   await startMcpServer();
 }
+if (import.meta.main) {
+  main().catch((error) => {
+    console.error("MCP server error:", error);
+    process.exit(1);
+  });
+}
 export {
   startMcpServer,
   createMcpServer,
+  buildServer,
   MCP_SERVER_INFO
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/brains",
-  "version": "0.0.23",
+  "version": "0.0.24",
   "description": "Fine-tuned model tracker and trainer — wraps OpenAI + Thinker Labs, gathers training data from todos/mementos/conversations/sessions",
   "type": "module",
   "main": "./dist/index.js",