@hasna/microservices 0.0.22 → 0.0.24

package/bin/mcp.js

@@ -15133,6 +15133,7 @@ config(en_default2());
 
 // node_modules/.bun/@modelcontextprotocol+sdk@1.27.1/node_modules/@modelcontextprotocol/sdk/dist/esm/types.js
 var LATEST_PROTOCOL_VERSION = "2025-11-25";
+var DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26";
 var SUPPORTED_PROTOCOL_VERSIONS = [LATEST_PROTOCOL_VERSION, "2025-06-18", "2025-03-26", "2024-11-05", "2024-10-07"];
 var RELATED_TASK_META_KEY = "io.modelcontextprotocol/related-task";
 var JSONRPC_VERSION = "2.0";
@@ -15305,6 +15306,7 @@ var InitializeRequestSchema = RequestSchema.extend({
   method: literal("initialize"),
   params: InitializeRequestParamsSchema
 });
+var isInitializeRequest = (value) => InitializeRequestSchema.safeParse(value).success;
 var ServerCapabilitiesSchema = object2({
   experimental: record(string2(), AssertObjectSchema).optional(),
   logging: AssertObjectSchema.optional(),
@@ -20073,407 +20075,1667 @@ async function runMicroserviceCommand(name, args, timeout = 30000) {
   });
 }
 
-// src/mcp/index.ts
-var server = new McpServer({
-  name: "microservices",
-  version: getPackageVersion()
-});
-server.registerTool("list_microservices", {
-  title: "List Microservices",
-  description: "List all 21 available production microservices (auth, teams, billing, llm, agents, memory, etc).",
-  inputSchema: { installed_only: exports_external.boolean().optional() }
-}, async ({ installed_only }) => {
-  const services = installed_only ? MICROSERVICES.filter((m) => microserviceExists(m.name)) : MICROSERVICES;
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(services.map((m) => ({
-          name: m.name,
-          package: m.package,
-          binary: m.binary,
-          category: m.category,
-          description: m.description,
-          schemaPrefix: m.schemaPrefix,
-          installed: microserviceExists(m.name),
-          requiredEnv: m.requiredEnv
-        })), null, 2)
+// src/mcp/http.ts
+import { createServer } from "http";
+
+// node_modules/.bun/@hono+node-server@1.19.11+88d33b5845f82712/node_modules/@hono/node-server/dist/index.mjs
+import { Http2ServerRequest as Http2ServerRequest2 } from "http2";
+import { Http2ServerRequest } from "http2";
+import { Readable } from "stream";
+import crypto2 from "crypto";
+var RequestError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RequestError";
+  }
+};
+var toRequestError = (e) => {
+  if (e instanceof RequestError) {
+    return e;
+  }
+  return new RequestError(e.message, { cause: e });
+};
+var GlobalRequest = global.Request;
+var Request = class extends GlobalRequest {
+  constructor(input, options) {
+    if (typeof input === "object" && getRequestCache in input) {
+      input = input[getRequestCache]();
+    }
+    if (typeof options?.body?.getReader !== "undefined") {
+      options.duplex ??= "half";
+    }
+    super(input, options);
+  }
+};
+var newHeadersFromIncoming = (incoming) => {
+  const headerRecord = [];
+  const rawHeaders = incoming.rawHeaders;
+  for (let i = 0;i < rawHeaders.length; i += 2) {
+    const { [i]: key, [i + 1]: value } = rawHeaders;
+    if (key.charCodeAt(0) !== 58) {
+      headerRecord.push([key, value]);
+    }
+  }
+  return new Headers(headerRecord);
+};
+var wrapBodyStream = Symbol("wrapBodyStream");
+var newRequestFromIncoming = (method, url, headers, incoming, abortController) => {
+  const init = {
+    method,
+    headers,
+    signal: abortController.signal
+  };
+  if (method === "TRACE") {
+    init.method = "GET";
+    const req = new Request(url, init);
+    Object.defineProperty(req, "method", {
+      get() {
+        return "TRACE";
+      }
+    });
+    return req;
+  }
+  if (!(method === "GET" || method === "HEAD")) {
+    if ("rawBody" in incoming && incoming.rawBody instanceof Buffer) {
+      init.body = new ReadableStream({
+        start(controller) {
+          controller.enqueue(incoming.rawBody);
+          controller.close();
+        }
+      });
+    } else if (incoming[wrapBodyStream]) {
+      let reader;
+      init.body = new ReadableStream({
+        async pull(controller) {
+          try {
+            reader ||= Readable.toWeb(incoming).getReader();
+            const { done, value } = await reader.read();
+            if (done) {
+              controller.close();
+            } else {
+              controller.enqueue(value);
+            }
+          } catch (error2) {
+            controller.error(error2);
+          }
+        }
+      });
+    } else {
+      init.body = Readable.toWeb(incoming);
+    }
+  }
+  return new Request(url, init);
+};
+var getRequestCache = Symbol("getRequestCache");
+var requestCache = Symbol("requestCache");
+var incomingKey = Symbol("incomingKey");
+var urlKey = Symbol("urlKey");
+var headersKey = Symbol("headersKey");
+var abortControllerKey = Symbol("abortControllerKey");
+var getAbortController = Symbol("getAbortController");
+var requestPrototype = {
+  get method() {
+    return this[incomingKey].method || "GET";
+  },
+  get url() {
+    return this[urlKey];
+  },
+  get headers() {
+    return this[headersKey] ||= newHeadersFromIncoming(this[incomingKey]);
+  },
+  [getAbortController]() {
+    this[getRequestCache]();
+    return this[abortControllerKey];
+  },
+  [getRequestCache]() {
+    this[abortControllerKey] ||= new AbortController;
+    return this[requestCache] ||= newRequestFromIncoming(this.method, this[urlKey], this.headers, this[incomingKey], this[abortControllerKey]);
+  }
+};
+[
+  "body",
+  "bodyUsed",
+  "cache",
+  "credentials",
+  "destination",
+  "integrity",
+  "mode",
+  "redirect",
+  "referrer",
+  "referrerPolicy",
+  "signal",
+  "keepalive"
+].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    get() {
+      return this[getRequestCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(requestPrototype, k, {
+    value: function() {
+      return this[getRequestCache]()[k]();
+    }
+  });
+});
+Object.setPrototypeOf(requestPrototype, Request.prototype);
+var newRequest = (incoming, defaultHostname) => {
+  const req = Object.create(requestPrototype);
+  req[incomingKey] = incoming;
+  const incomingUrl = incoming.url || "";
+  if (incomingUrl[0] !== "/" && (incomingUrl.startsWith("http://") || incomingUrl.startsWith("https://"))) {
+    if (incoming instanceof Http2ServerRequest) {
+      throw new RequestError("Absolute URL for :path is not allowed in HTTP/2");
+    }
+    try {
+      const url2 = new URL(incomingUrl);
+      req[urlKey] = url2.href;
+    } catch (e) {
+      throw new RequestError("Invalid absolute URL", { cause: e });
+    }
+    return req;
+  }
+  const host = (incoming instanceof Http2ServerRequest ? incoming.authority : incoming.headers.host) || defaultHostname;
+  if (!host) {
+    throw new RequestError("Missing host header");
+  }
+  let scheme;
+  if (incoming instanceof Http2ServerRequest) {
+    scheme = incoming.scheme;
+    if (!(scheme === "http" || scheme === "https")) {
+      throw new RequestError("Unsupported scheme");
+    }
+  } else {
+    scheme = incoming.socket && incoming.socket.encrypted ? "https" : "http";
+  }
+  const url = new URL(`${scheme}://${host}${incomingUrl}`);
+  if (url.hostname.length !== host.length && url.hostname !== host.replace(/:\d+$/, "")) {
+    throw new RequestError("Invalid host header");
+  }
+  req[urlKey] = url.href;
+  return req;
+};
+var responseCache = Symbol("responseCache");
+var getResponseCache = Symbol("getResponseCache");
+var cacheKey = Symbol("cache");
+var GlobalResponse = global.Response;
+var Response2 = class _Response {
+  #body;
+  #init;
+  [getResponseCache]() {
+    delete this[cacheKey];
+    return this[responseCache] ||= new GlobalResponse(this.#body, this.#init);
+  }
+  constructor(body, init) {
+    let headers;
+    this.#body = body;
+    if (init instanceof _Response) {
+      const cachedGlobalResponse = init[responseCache];
+      if (cachedGlobalResponse) {
+        this.#init = cachedGlobalResponse;
+        this[getResponseCache]();
+        return;
+      } else {
+        this.#init = init.#init;
+        headers = new Headers(init.#init.headers);
+      }
+    } else {
+      this.#init = init;
+    }
+    if (typeof body === "string" || typeof body?.getReader !== "undefined" || body instanceof Blob || body instanceof Uint8Array) {
+      this[cacheKey] = [init?.status || 200, body, headers || init?.headers];
+    }
+  }
+  get headers() {
+    const cache = this[cacheKey];
+    if (cache) {
+      if (!(cache[2] instanceof Headers)) {
+        cache[2] = new Headers(cache[2] || { "content-type": "text/plain; charset=UTF-8" });
+      }
+      return cache[2];
+    }
+    return this[getResponseCache]().headers;
+  }
+  get status() {
+    return this[cacheKey]?.[0] ?? this[getResponseCache]().status;
+  }
+  get ok() {
+    const status = this.status;
+    return status >= 200 && status < 300;
+  }
+};
+["body", "bodyUsed", "redirected", "statusText", "trailers", "type", "url"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    get() {
+      return this[getResponseCache]()[k];
+    }
+  });
+});
+["arrayBuffer", "blob", "clone", "formData", "json", "text"].forEach((k) => {
+  Object.defineProperty(Response2.prototype, k, {
+    value: function() {
+      return this[getResponseCache]()[k]();
+    }
+  });
+});
+Object.setPrototypeOf(Response2, GlobalResponse);
+Object.setPrototypeOf(Response2.prototype, GlobalResponse.prototype);
+async function readWithoutBlocking(readPromise) {
+  return Promise.race([readPromise, Promise.resolve().then(() => Promise.resolve(undefined))]);
+}
+function writeFromReadableStreamDefaultReader(reader, writable, currentReadPromise) {
+  const cancel = (error2) => {
+    reader.cancel(error2).catch(() => {});
+  };
+  writable.on("close", cancel);
+  writable.on("error", cancel);
+  (currentReadPromise ?? reader.read()).then(flow, handleStreamError);
+  return reader.closed.finally(() => {
+    writable.off("close", cancel);
+    writable.off("error", cancel);
+  });
+  function handleStreamError(error2) {
+    if (error2) {
+      writable.destroy(error2);
+    }
+  }
+  function onDrain() {
+    reader.read().then(flow, handleStreamError);
+  }
+  function flow({ done, value }) {
+    try {
+      if (done) {
+        writable.end();
+      } else if (!writable.write(value)) {
+        writable.once("drain", onDrain);
+      } else {
+        return reader.read().then(flow, handleStreamError);
+      }
+    } catch (e) {
+      handleStreamError(e);
+    }
+  }
+}
+function writeFromReadableStream(stream, writable) {
+  if (stream.locked) {
+    throw new TypeError("ReadableStream is locked.");
+  } else if (writable.destroyed) {
+    return;
+  }
+  return writeFromReadableStreamDefaultReader(stream.getReader(), writable);
+}
+var buildOutgoingHttpHeaders = (headers) => {
+  const res = {};
+  if (!(headers instanceof Headers)) {
+    headers = new Headers(headers ?? undefined);
+  }
+  const cookies = [];
+  for (const [k, v] of headers) {
+    if (k === "set-cookie") {
+      cookies.push(v);
+    } else {
+      res[k] = v;
+    }
+  }
+  if (cookies.length > 0) {
+    res["set-cookie"] = cookies;
+  }
+  res["content-type"] ??= "text/plain; charset=UTF-8";
+  return res;
+};
+var X_ALREADY_SENT = "x-hono-already-sent";
+if (typeof global.crypto === "undefined") {
+  global.crypto = crypto2;
+}
+var outgoingEnded = Symbol("outgoingEnded");
+var handleRequestError = () => new Response(null, {
+  status: 400
+});
+var handleFetchError = (e) => new Response(null, {
+  status: e instanceof Error && (e.name === "TimeoutError" || e.constructor.name === "TimeoutError") ? 504 : 500
+});
+var handleResponseError = (e, outgoing) => {
+  const err = e instanceof Error ? e : new Error("unknown error", { cause: e });
+  if (err.code === "ERR_STREAM_PREMATURE_CLOSE") {
+    console.info("The user aborted a request.");
+  } else {
+    console.error(e);
+    if (!outgoing.headersSent) {
+      outgoing.writeHead(500, { "Content-Type": "text/plain" });
+    }
+    outgoing.end(`Error: ${err.message}`);
+    outgoing.destroy(err);
+  }
+};
+var flushHeaders = (outgoing) => {
+  if ("flushHeaders" in outgoing && outgoing.writable) {
+    outgoing.flushHeaders();
+  }
+};
+var responseViaCache = async (res, outgoing) => {
+  let [status, body, header] = res[cacheKey];
+  let hasContentLength = false;
+  if (!header) {
+    header = { "content-type": "text/plain; charset=UTF-8" };
+  } else if (header instanceof Headers) {
+    hasContentLength = header.has("content-length");
+    header = buildOutgoingHttpHeaders(header);
+  } else if (Array.isArray(header)) {
+    const headerObj = new Headers(header);
+    hasContentLength = headerObj.has("content-length");
+    header = buildOutgoingHttpHeaders(headerObj);
+  } else {
+    for (const key in header) {
+      if (key.length === 14 && key.toLowerCase() === "content-length") {
+        hasContentLength = true;
+        break;
+      }
+    }
+  }
+  if (!hasContentLength) {
+    if (typeof body === "string") {
+      header["Content-Length"] = Buffer.byteLength(body);
+    } else if (body instanceof Uint8Array) {
+      header["Content-Length"] = body.byteLength;
+    } else if (body instanceof Blob) {
+      header["Content-Length"] = body.size;
+    }
+  }
+  outgoing.writeHead(status, header);
+  if (typeof body === "string" || body instanceof Uint8Array) {
+    outgoing.end(body);
+  } else if (body instanceof Blob) {
+    outgoing.end(new Uint8Array(await body.arrayBuffer()));
+  } else {
+    flushHeaders(outgoing);
+    await writeFromReadableStream(body, outgoing)?.catch((e) => handleResponseError(e, outgoing));
+  }
+  outgoing[outgoingEnded]?.();
+};
+var isPromise = (res) => typeof res.then === "function";
+var responseViaResponseObject = async (res, outgoing, options = {}) => {
+  if (isPromise(res)) {
+    if (options.errorHandler) {
+      try {
+        res = await res;
+      } catch (err) {
+        const errRes = await options.errorHandler(err);
+        if (!errRes) {
+          return;
+        }
+        res = errRes;
+      }
+    } else {
+      res = await res.catch(handleFetchError);
+    }
+  }
+  if (cacheKey in res) {
+    return responseViaCache(res, outgoing);
+  }
+  const resHeaderRecord = buildOutgoingHttpHeaders(res.headers);
+  if (res.body) {
+    const reader = res.body.getReader();
+    const values = [];
+    let done = false;
+    let currentReadPromise = undefined;
+    if (resHeaderRecord["transfer-encoding"] !== "chunked") {
+      let maxReadCount = 2;
+      for (let i = 0;i < maxReadCount; i++) {
+        currentReadPromise ||= reader.read();
+        const chunk = await readWithoutBlocking(currentReadPromise).catch((e) => {
+          console.error(e);
+          done = true;
+        });
+        if (!chunk) {
+          if (i === 1) {
+            await new Promise((resolve2) => setTimeout(resolve2));
+            maxReadCount = 3;
+            continue;
+          }
+          break;
+        }
+        currentReadPromise = undefined;
+        if (chunk.value) {
+          values.push(chunk.value);
+        }
+        if (chunk.done) {
+          done = true;
+          break;
+        }
+      }
+      if (done && !("content-length" in resHeaderRecord)) {
+        resHeaderRecord["content-length"] = values.reduce((acc, value) => acc + value.length, 0);
+      }
+    }
+    outgoing.writeHead(res.status, resHeaderRecord);
+    values.forEach((value) => {
+      outgoing.write(value);
+    });
+    if (done) {
+      outgoing.end();
+    } else {
+      if (values.length === 0) {
+        flushHeaders(outgoing);
+      }
+      await writeFromReadableStreamDefaultReader(reader, outgoing, currentReadPromise);
+    }
+  } else if (resHeaderRecord[X_ALREADY_SENT]) {} else {
+    outgoing.writeHead(res.status, resHeaderRecord);
+    outgoing.end();
+  }
+  outgoing[outgoingEnded]?.();
+};
+var getRequestListener = (fetchCallback, options = {}) => {
+  const autoCleanupIncoming = options.autoCleanupIncoming ?? true;
+  if (options.overrideGlobalObjects !== false && global.Request !== Request) {
+    Object.defineProperty(global, "Request", {
+      value: Request
+    });
+    Object.defineProperty(global, "Response", {
+      value: Response2
+    });
+  }
+  return async (incoming, outgoing) => {
+    let res, req;
+    try {
+      req = newRequest(incoming, options.hostname);
+      let incomingEnded = !autoCleanupIncoming || incoming.method === "GET" || incoming.method === "HEAD";
+      if (!incomingEnded) {
+        incoming[wrapBodyStream] = true;
+        incoming.on("end", () => {
+          incomingEnded = true;
+        });
+        if (incoming instanceof Http2ServerRequest2) {
+          outgoing[outgoingEnded] = () => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                if (!incomingEnded) {
+                  setTimeout(() => {
+                    incoming.destroy();
+                    outgoing.destroy();
+                  });
+                }
+              });
+            }
+          };
+        }
+      }
+      outgoing.on("close", () => {
+        const abortController = req[abortControllerKey];
+        if (abortController) {
+          if (incoming.errored) {
+            req[abortControllerKey].abort(incoming.errored.toString());
+          } else if (!outgoing.writableFinished) {
+            req[abortControllerKey].abort("Client connection prematurely closed.");
+          }
+        }
+        if (!incomingEnded) {
+          setTimeout(() => {
+            if (!incomingEnded) {
+              setTimeout(() => {
+                incoming.destroy();
+              });
+            }
+          });
+        }
+      });
+      res = fetchCallback(req, { incoming, outgoing });
+      if (cacheKey in res) {
+        return responseViaCache(res, outgoing);
+      }
+    } catch (e) {
+      if (!res) {
+        if (options.errorHandler) {
+          res = await options.errorHandler(req ? e : toRequestError(e));
+          if (!res) {
+            return;
+          }
+        } else if (!req) {
+          res = handleRequestError();
+        } else {
+          res = handleFetchError(e);
+        }
+      } else {
+        return handleResponseError(e, outgoing);
+      }
+    }
+    try {
+      return await responseViaResponseObject(res, outgoing, options);
+    } catch (e) {
+      return handleResponseError(e, outgoing);
+    }
+  };
+};
+
+// node_modules/.bun/@modelcontextprotocol+sdk@1.27.1/node_modules/@modelcontextprotocol/sdk/dist/esm/server/webStandardStreamableHttp.js
+class WebStandardStreamableHTTPServerTransport {
+  constructor(options = {}) {
+    this._started = false;
+    this._hasHandledRequest = false;
+    this._streamMapping = new Map;
+    this._requestToStreamMapping = new Map;
+    this._requestResponseMap = new Map;
+    this._initialized = false;
+    this._enableJsonResponse = false;
+    this._standaloneSseStreamId = "_GET_stream";
+    this.sessionIdGenerator = options.sessionIdGenerator;
+    this._enableJsonResponse = options.enableJsonResponse ?? false;
+    this._eventStore = options.eventStore;
+    this._onsessioninitialized = options.onsessioninitialized;
+    this._onsessionclosed = options.onsessionclosed;
+    this._allowedHosts = options.allowedHosts;
+    this._allowedOrigins = options.allowedOrigins;
+    this._enableDnsRebindingProtection = options.enableDnsRebindingProtection ?? false;
+    this._retryInterval = options.retryInterval;
+  }
+  async start() {
+    if (this._started) {
+      throw new Error("Transport already started");
+    }
+    this._started = true;
+  }
+  createJsonErrorResponse(status, code, message, options) {
+    const error2 = { code, message };
+    if (options?.data !== undefined) {
+      error2.data = options.data;
+    }
+    return new Response(JSON.stringify({
+      jsonrpc: "2.0",
+      error: error2,
+      id: null
+    }), {
+      status,
+      headers: {
+        "Content-Type": "application/json",
+        ...options?.headers
+      }
+    });
+  }
+  validateRequestHeaders(req) {
+    if (!this._enableDnsRebindingProtection) {
+      return;
+    }
+    if (this._allowedHosts && this._allowedHosts.length > 0) {
+      const hostHeader = req.headers.get("host");
+      if (!hostHeader || !this._allowedHosts.includes(hostHeader)) {
+        const error2 = `Invalid Host header: ${hostHeader}`;
+        this.onerror?.(new Error(error2));
+        return this.createJsonErrorResponse(403, -32000, error2);
+      }
+    }
+    if (this._allowedOrigins && this._allowedOrigins.length > 0) {
+      const originHeader = req.headers.get("origin");
+      if (originHeader && !this._allowedOrigins.includes(originHeader)) {
+        const error2 = `Invalid Origin header: ${originHeader}`;
+        this.onerror?.(new Error(error2));
+        return this.createJsonErrorResponse(403, -32000, error2);
+      }
+    }
+    return;
+  }
+  async handleRequest(req, options) {
+    if (!this.sessionIdGenerator && this._hasHandledRequest) {
+      throw new Error("Stateless transport cannot be reused across requests. Create a new transport per request.");
+    }
+    this._hasHandledRequest = true;
+    const validationError = this.validateRequestHeaders(req);
+    if (validationError) {
+      return validationError;
+    }
+    switch (req.method) {
+      case "POST":
+        return this.handlePostRequest(req, options);
+      case "GET":
+        return this.handleGetRequest(req);
+      case "DELETE":
+        return this.handleDeleteRequest(req);
+      default:
+        return this.handleUnsupportedRequest();
+    }
+  }
+  async writePrimingEvent(controller, encoder, streamId, protocolVersion) {
+    if (!this._eventStore) {
+      return;
+    }
+    if (protocolVersion < "2025-11-25") {
+      return;
+    }
+    const primingEventId = await this._eventStore.storeEvent(streamId, {});
+    let primingEvent = `id: ${primingEventId}
+data: 
+
+`;
+    if (this._retryInterval !== undefined) {
+      primingEvent = `id: ${primingEventId}
+retry: ${this._retryInterval}
+data: 
+
+`;
+    }
+    controller.enqueue(encoder.encode(primingEvent));
+  }
+  async handleGetRequest(req) {
+    const acceptHeader = req.headers.get("accept");
+    if (!acceptHeader?.includes("text/event-stream")) {
+      this.onerror?.(new Error("Not Acceptable: Client must accept text/event-stream"));
+      return this.createJsonErrorResponse(406, -32000, "Not Acceptable: Client must accept text/event-stream");
+    }
+    const sessionError = this.validateSession(req);
+    if (sessionError) {
+      return sessionError;
+    }
+    const protocolError = this.validateProtocolVersion(req);
+    if (protocolError) {
+      return protocolError;
+    }
+    if (this._eventStore) {
+      const lastEventId = req.headers.get("last-event-id");
+      if (lastEventId) {
+        return this.replayEvents(lastEventId);
+      }
+    }
+    if (this._streamMapping.get(this._standaloneSseStreamId) !== undefined) {
+      this.onerror?.(new Error("Conflict: Only one SSE stream is allowed per session"));
+      return this.createJsonErrorResponse(409, -32000, "Conflict: Only one SSE stream is allowed per session");
+    }
+    const encoder = new TextEncoder;
+    let streamController;
+    const readable = new ReadableStream({
+      start: (controller) => {
+        streamController = controller;
+      },
+      cancel: () => {
+        this._streamMapping.delete(this._standaloneSseStreamId);
+      }
+    });
+    const headers = {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache, no-transform",
+      Connection: "keep-alive"
+    };
+    if (this.sessionId !== undefined) {
+      headers["mcp-session-id"] = this.sessionId;
+    }
+    this._streamMapping.set(this._standaloneSseStreamId, {
+      controller: streamController,
+      encoder,
+      cleanup: () => {
+        this._streamMapping.delete(this._standaloneSseStreamId);
+        try {
+          streamController.close();
+        } catch {}
+      }
+    });
+    return new Response(readable, { headers });
+  }
+  async replayEvents(lastEventId) {
+    if (!this._eventStore) {
+      this.onerror?.(new Error("Event store not configured"));
+      return this.createJsonErrorResponse(400, -32000, "Event store not configured");
+    }
+    try {
+      let streamId;
+      if (this._eventStore.getStreamIdForEventId) {
+        streamId = await this._eventStore.getStreamIdForEventId(lastEventId);
+        if (!streamId) {
+          this.onerror?.(new Error("Invalid event ID format"));
+          return this.createJsonErrorResponse(400, -32000, "Invalid event ID format");
+        }
+        if (this._streamMapping.get(streamId) !== undefined) {
+          this.onerror?.(new Error("Conflict: Stream already has an active connection"));
+          return this.createJsonErrorResponse(409, -32000, "Conflict: Stream already has an active connection");
+        }
+      }
+      const headers = {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-transform",
+        Connection: "keep-alive"
+      };
+      if (this.sessionId !== undefined) {
+        headers["mcp-session-id"] = this.sessionId;
+      }
+      const encoder = new TextEncoder;
+      let streamController;
+      const readable = new ReadableStream({
+        start: (controller) => {
+          streamController = controller;
+        },
+        cancel: () => {}
+      });
+      const replayedStreamId = await this._eventStore.replayEventsAfter(lastEventId, {
+        send: async (eventId, message) => {
+          const success = this.writeSSEEvent(streamController, encoder, message, eventId);
+          if (!success) {
+            this.onerror?.(new Error("Failed replay events"));
+            try {
+              streamController.close();
+            } catch {}
+          }
+        }
+      });
+      this._streamMapping.set(replayedStreamId, {
+        controller: streamController,
+        encoder,
+        cleanup: () => {
+          this._streamMapping.delete(replayedStreamId);
+          try {
+            streamController.close();
+          } catch {}
+        }
+      });
+      return new Response(readable, { headers });
+    } catch (error2) {
+      this.onerror?.(error2);
+      return this.createJsonErrorResponse(500, -32000, "Error replaying events");
+    }
+  }
+  writeSSEEvent(controller, encoder, message, eventId) {
+    try {
+      let eventData = `event: message
+`;
+      if (eventId) {
+        eventData += `id: ${eventId}
+`;
+      }
+      eventData += `data: ${JSON.stringify(message)}
+
+`;
+      controller.enqueue(encoder.encode(eventData));
+      return true;
+    } catch (error2) {
+      this.onerror?.(error2);
+      return false;
+    }
+  }
+  handleUnsupportedRequest() {
+    this.onerror?.(new Error("Method not allowed."));
+    return new Response(JSON.stringify({
+      jsonrpc: "2.0",
+      error: {
+        code: -32000,
+        message: "Method not allowed."
+      },
+      id: null
+    }), {
+      status: 405,
+      headers: {
+        Allow: "GET, POST, DELETE",
+        "Content-Type": "application/json"
+      }
+    });
+  }
+  async handlePostRequest(req, options) {
+    try {
+      const acceptHeader = req.headers.get("accept");
+      if (!acceptHeader?.includes("application/json") || !acceptHeader.includes("text/event-stream")) {
+        this.onerror?.(new Error("Not Acceptable: Client must accept both application/json and text/event-stream"));
+        return this.createJsonErrorResponse(406, -32000, "Not Acceptable: Client must accept both application/json and text/event-stream");
+      }
+      const ct = req.headers.get("content-type");
+      if (!ct || !ct.includes("application/json")) {
+        this.onerror?.(new Error("Unsupported Media Type: Content-Type must be application/json"));
+        return this.createJsonErrorResponse(415, -32000, "Unsupported Media Type: Content-Type must be application/json");
+      }
+      const requestInfo = {
+        headers: Object.fromEntries(req.headers.entries()),
+        url: new URL(req.url)
+      };
+      let rawMessage;
+      if (options?.parsedBody !== undefined) {
+        rawMessage = options.parsedBody;
+      } else {
+        try {
+          rawMessage = await req.json();
+        } catch {
+          this.onerror?.(new Error("Parse error: Invalid JSON"));
+          return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON");
+        }
+      }
+      let messages;
+      try {
+        if (Array.isArray(rawMessage)) {
+          messages = rawMessage.map((msg) => JSONRPCMessageSchema.parse(msg));
+        } else {
+          messages = [JSONRPCMessageSchema.parse(rawMessage)];
+        }
+      } catch {
+        this.onerror?.(new Error("Parse error: Invalid JSON-RPC message"));
+        return this.createJsonErrorResponse(400, -32700, "Parse error: Invalid JSON-RPC message");
+      }
+      const isInitializationRequest = messages.some(isInitializeRequest);
+      if (isInitializationRequest) {
+        if (this._initialized && this.sessionId !== undefined) {
+          this.onerror?.(new Error("Invalid Request: Server already initialized"));
+          return this.createJsonErrorResponse(400, -32600, "Invalid Request: Server already initialized");
+        }
+        if (messages.length > 1) {
+          this.onerror?.(new Error("Invalid Request: Only one initialization request is allowed"));
+          return this.createJsonErrorResponse(400, -32600, "Invalid Request: Only one initialization request is allowed");
+        }
+        this.sessionId = this.sessionIdGenerator?.();
+        this._initialized = true;
+        if (this.sessionId && this._onsessioninitialized) {
+          await Promise.resolve(this._onsessioninitialized(this.sessionId));
+        }
+      }
+      if (!isInitializationRequest) {
+        const sessionError = this.validateSession(req);
+        if (sessionError) {
+          return sessionError;
+        }
+        const protocolError = this.validateProtocolVersion(req);
+        if (protocolError) {
+          return protocolError;
+        }
+      }
+      const hasRequests = messages.some(isJSONRPCRequest);
+      if (!hasRequests) {
+        for (const message of messages) {
+          this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo });
+        }
+        return new Response(null, { status: 202 });
+      }
+      const streamId = crypto.randomUUID();
+      const initRequest = messages.find((m) => isInitializeRequest(m));
+      const clientProtocolVersion = initRequest ? initRequest.params.protocolVersion : req.headers.get("mcp-protocol-version") ?? DEFAULT_NEGOTIATED_PROTOCOL_VERSION;
+      if (this._enableJsonResponse) {
+        return new Promise((resolve2) => {
+          this._streamMapping.set(streamId, {
+            resolveJson: resolve2,
+            cleanup: () => {
+              this._streamMapping.delete(streamId);
+            }
+          });
+          for (const message of messages) {
+            if (isJSONRPCRequest(message)) {
+              this._requestToStreamMapping.set(message.id, streamId);
+            }
+          }
+          for (const message of messages) {
+            this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo });
+          }
+        });
+      }
+      const encoder = new TextEncoder;
+      let streamController;
+      const readable = new ReadableStream({
+        start: (controller) => {
+          streamController = controller;
+        },
+        cancel: () => {
+          this._streamMapping.delete(streamId);
+        }
+      });
+      const headers = {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache",
+        Connection: "keep-alive"
+      };
+      if (this.sessionId !== undefined) {
+        headers["mcp-session-id"] = this.sessionId;
+      }
+      for (const message of messages) {
+        if (isJSONRPCRequest(message)) {
+          this._streamMapping.set(streamId, {
+            controller: streamController,
+            encoder,
+            cleanup: () => {
+              this._streamMapping.delete(streamId);
+              try {
+                streamController.close();
+              } catch {}
+            }
+          });
+          this._requestToStreamMapping.set(message.id, streamId);
+        }
+      }
+      await this.writePrimingEvent(streamController, encoder, streamId, clientProtocolVersion);
+      for (const message of messages) {
+        let closeSSEStream;
+        let closeStandaloneSSEStream;
+        if (isJSONRPCRequest(message) && this._eventStore && clientProtocolVersion >= "2025-11-25") {
+          closeSSEStream = () => {
+            this.closeSSEStream(message.id);
+          };
+          closeStandaloneSSEStream = () => {
+            this.closeStandaloneSSEStream();
+          };
+        }
+        this.onmessage?.(message, { authInfo: options?.authInfo, requestInfo, closeSSEStream, closeStandaloneSSEStream });
+      }
+      return new Response(readable, { status: 200, headers });
+    } catch (error2) {
+      this.onerror?.(error2);
+      return this.createJsonErrorResponse(400, -32700, "Parse error", { data: String(error2) });
+    }
+  }
+  async handleDeleteRequest(req) {
+    const sessionError = this.validateSession(req);
+    if (sessionError) {
+      return sessionError;
+    }
+    const protocolError = this.validateProtocolVersion(req);
+    if (protocolError) {
+      return protocolError;
+    }
+    await Promise.resolve(this._onsessionclosed?.(this.sessionId));
+    await this.close();
+    return new Response(null, { status: 200 });
+  }
+  validateSession(req) {
+    if (this.sessionIdGenerator === undefined) {
+      return;
+    }
+    if (!this._initialized) {
+      this.onerror?.(new Error("Bad Request: Server not initialized"));
+      return this.createJsonErrorResponse(400, -32000, "Bad Request: Server not initialized");
+    }
+    const sessionId = req.headers.get("mcp-session-id");
+    if (!sessionId) {
+      this.onerror?.(new Error("Bad Request: Mcp-Session-Id header is required"));
+      return this.createJsonErrorResponse(400, -32000, "Bad Request: Mcp-Session-Id header is required");
+    }
+    if (sessionId !== this.sessionId) {
+      this.onerror?.(new Error("Session not found"));
+      return this.createJsonErrorResponse(404, -32001, "Session not found");
+    }
+    return;
+  }
+  validateProtocolVersion(req) {
+    const protocolVersion = req.headers.get("mcp-protocol-version");
+    if (protocolVersion !== null && !SUPPORTED_PROTOCOL_VERSIONS.includes(protocolVersion)) {
+      this.onerror?.(new Error(`Bad Request: Unsupported protocol version: ${protocolVersion}` + ` (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`));
+      return this.createJsonErrorResponse(400, -32000, `Bad Request: Unsupported protocol version: ${protocolVersion} (supported versions: ${SUPPORTED_PROTOCOL_VERSIONS.join(", ")})`);
+    }
+    return;
+  }
+  async close() {
+    this._streamMapping.forEach(({ cleanup }) => {
+      cleanup();
+    });
+    this._streamMapping.clear();
+    this._requestResponseMap.clear();
+    this.onclose?.();
+  }
+  closeSSEStream(requestId) {
+    const streamId = this._requestToStreamMapping.get(requestId);
+    if (!streamId)
+      return;
+    const stream = this._streamMapping.get(streamId);
+    if (stream) {
+      stream.cleanup();
+    }
+  }
+  closeStandaloneSSEStream() {
+    const stream = this._streamMapping.get(this._standaloneSseStreamId);
+    if (stream) {
+      stream.cleanup();
+    }
+  }
+  async send(message, options) {
+    let requestId = options?.relatedRequestId;
+    if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+      requestId = message.id;
+    }
+    if (requestId === undefined) {
+      if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+        throw new Error("Cannot send a response on a standalone SSE stream unless resuming a previous client request");
+      }
+      let eventId;
+      if (this._eventStore) {
+        eventId = await this._eventStore.storeEvent(this._standaloneSseStreamId, message);
+      }
+      const standaloneSse = this._streamMapping.get(this._standaloneSseStreamId);
+      if (standaloneSse === undefined) {
+        return;
+      }
+      if (standaloneSse.controller && standaloneSse.encoder) {
+        this.writeSSEEvent(standaloneSse.controller, standaloneSse.encoder, message, eventId);
+      }
+      return;
+    }
+    const streamId = this._requestToStreamMapping.get(requestId);
+    if (!streamId) {
+      throw new Error(`No connection established for request ID: ${String(requestId)}`);
+    }
+    const stream = this._streamMapping.get(streamId);
+    if (!this._enableJsonResponse && stream?.controller && stream?.encoder) {
+      let eventId;
+      if (this._eventStore) {
+        eventId = await this._eventStore.storeEvent(streamId, message);
+      }
+      this.writeSSEEvent(stream.controller, stream.encoder, message, eventId);
+    }
+    if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
+      this._requestResponseMap.set(requestId, message);
+      const relatedIds = Array.from(this._requestToStreamMapping.entries()).filter(([_, sid]) => sid === streamId).map(([id]) => id);
+      const allResponsesReady = relatedIds.every((id) => this._requestResponseMap.has(id));
+      if (allResponsesReady) {
+        if (!stream) {
+          throw new Error(`No connection established for request ID: ${String(requestId)}`);
+        }
+        if (this._enableJsonResponse && stream.resolveJson) {
+          const headers = {
+            "Content-Type": "application/json"
+          };
+          if (this.sessionId !== undefined) {
+            headers["mcp-session-id"] = this.sessionId;
+          }
+          const responses = relatedIds.map((id) => this._requestResponseMap.get(id));
+          if (responses.length === 1) {
+            stream.resolveJson(new Response(JSON.stringify(responses[0]), { status: 200, headers }));
+          } else {
+            stream.resolveJson(new Response(JSON.stringify(responses), { status: 200, headers }));
+          }
+        } else {
+          stream.cleanup();
+        }
+        for (const id of relatedIds) {
+          this._requestResponseMap.delete(id);
+          this._requestToStreamMapping.delete(id);
+        }
+      }
+    }
+  }
+}
+
+// node_modules/.bun/@modelcontextprotocol+sdk@1.27.1/node_modules/@modelcontextprotocol/sdk/dist/esm/server/streamableHttp.js
+class StreamableHTTPServerTransport {
+  constructor(options = {}) {
+    this._requestContext = new WeakMap;
+    this._webStandardTransport = new WebStandardStreamableHTTPServerTransport(options);
+    this._requestListener = getRequestListener(async (webRequest) => {
+      const context = this._requestContext.get(webRequest);
+      return this._webStandardTransport.handleRequest(webRequest, {
+        authInfo: context?.authInfo,
+        parsedBody: context?.parsedBody
+      });
+    }, { overrideGlobalObjects: false });
+  }
+  get sessionId() {
+    return this._webStandardTransport.sessionId;
+  }
+  set onclose(handler) {
+    this._webStandardTransport.onclose = handler;
+  }
+  get onclose() {
+    return this._webStandardTransport.onclose;
+  }
+  set onerror(handler) {
+    this._webStandardTransport.onerror = handler;
+  }
+  get onerror() {
+    return this._webStandardTransport.onerror;
+  }
+  set onmessage(handler) {
+    this._webStandardTransport.onmessage = handler;
+  }
+  get onmessage() {
+    return this._webStandardTransport.onmessage;
+  }
+  async start() {
+    return this._webStandardTransport.start();
+  }
+  async close() {
+    return this._webStandardTransport.close();
+  }
+  async send(message, options) {
+    return this._webStandardTransport.send(message, options);
+  }
+  async handleRequest(req, res, parsedBody) {
+    const authInfo = req.auth;
+    const handler = getRequestListener(async (webRequest) => {
+      return this._webStandardTransport.handleRequest(webRequest, {
+        authInfo,
+        parsedBody
+      });
+    }, { overrideGlobalObjects: false });
+    await handler(req, res);
+  }
+  closeSSEStream(requestId) {
+    this._webStandardTransport.closeSSEStream(requestId);
+  }
+  closeStandaloneSSEStream() {
+    this._webStandardTransport.closeStandaloneSSEStream();
+  }
+}
+
+// src/mcp/http.ts
+var MCP_HTTP_SERVICE_NAME = "microservices";
+var DEFAULT_MCP_HTTP_PORT = 8825;
+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 text = Buffer.concat(chunks).toString("utf8");
+  if (!text)
+    return;
+  return JSON.parse(text);
+}
+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;
       }
-    ]
-  };
-});
-server.registerTool("search_microservices", {
-  title: "Search Microservices",
-  description: "Search microservices by name, description, or tags.",
-  inputSchema: { query: exports_external.string() }
-}, async ({ query }) => {
-  const results = searchMicroservices(query);
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(results.map((m) => ({
-          name: m.name,
-          package: m.package,
-          description: m.description,
-          category: m.category,
-          tags: m.tags
-        })), null, 2)
+      if (url.pathname !== "/mcp") {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not Found");
+        return;
       }
-    ]
-  };
-});
-server.registerTool("install_microservice", {
-  title: "Install Microservice",
-  description: "Install a microservice globally via bun install -g.",
-  inputSchema: { name: exports_external.string(), force: exports_external.boolean().optional() }
-}, async ({ name, force }) => {
-  const result = installMicroservice(name, { force });
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(result, null, 2)
+      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 (error2) {
+      console.error(`[${serviceName}-mcp] HTTP error:`, error2);
+      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((resolve2, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(requestedPort, host, () => resolve2());
+  });
+  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((resolve2, reject) => {
+      httpServer.close((err) => err ? reject(err) : resolve2());
+    })
   };
-});
-server.registerTool("microservice_status", {
-  title: "Microservice Status",
-  description: "Check if a microservice is installed and get its version.",
-  inputSchema: { name: exports_external.string().optional() }
-}, async ({ name }) => {
-  if (name) {
+}
+
+// src/mcp/index.ts
+function hasFlag(...flags) {
+  return process.argv.some((arg) => flags.includes(arg));
+}
+function printHelp() {
+  process.stdout.write(`Usage: microservices-mcp [options]
+
+Microservices MCP server (stdio transport by default)
+
+Options:
+  --http           Serve MCP over Streamable HTTP (127.0.0.1)
+  --port <number>  HTTP port (default: 8825, env: MCP_HTTP_PORT)
+  -h, --help       Show help
+  -V, --version    Show version
+`);
+}
+function buildServer() {
+  const server = new McpServer({
+    name: "microservices",
+    version: getPackageVersion()
+  });
+  server.registerTool("list_microservices", {
+    title: "List Microservices",
+    description: "List all 21 available production microservices (auth, teams, billing, llm, agents, memory, etc).",
+    inputSchema: { installed_only: exports_external.boolean().optional() }
+  }, async ({ installed_only }) => {
+    const services = installed_only ? MICROSERVICES.filter((m) => microserviceExists(m.name)) : MICROSERVICES;
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify(getMicroserviceStatus(name), null, 2)
+          text: JSON.stringify(services.map((m) => ({
+            name: m.name,
+            package: m.package,
+            binary: m.binary,
+            category: m.category,
+            description: m.description,
+            schemaPrefix: m.schemaPrefix,
+            installed: microserviceExists(m.name),
+            requiredEnv: m.requiredEnv
+          })), null, 2)
         }
       ]
     };
-  }
-  const statuses = MICROSERVICES.map((m) => getMicroserviceStatus(m.name));
-  return {
-    content: [{ type: "text", text: JSON.stringify(statuses, null, 2) }]
-  };
-});
-server.registerTool("run_microservice_command", {
-  title: "Run Microservice Command",
-  description: "Run a CLI command on an installed microservice. Example: run migrate, serve, status.",
-  inputSchema: {
-    name: exports_external.string().describe("Microservice name (e.g. 'auth', 'billing')"),
-    args: exports_external.array(exports_external.string()).describe("CLI arguments (e.g. ['migrate'] or ['status'])")
-  }
-}, async ({ name, args }) => {
-  const result = await runMicroserviceCommand(name, args);
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          success: result.success,
-          exitCode: result.exitCode,
-          stdout: result.stdout,
-          stderr: result.stderr
-        }, null, 2)
-      }
-    ]
-  };
-});
-server.registerTool("check_env", {
-  title: "Check Environment Variables",
-  description: "Verify if all required and optional environment variables are set for installed microservices.",
-  inputSchema: {}
-}, async () => {
-  const installed = MICROSERVICES.filter((m) => microserviceExists(m.name));
-  if (installed.length === 0) {
+  });
+  server.registerTool("search_microservices", {
+    title: "Search Microservices",
+    description: "Search microservices by name, description, or tags.",
+    inputSchema: { query: exports_external.string() }
+  }, async ({ query }) => {
+    const results = searchMicroservices(query);
     return {
       content: [
-        { type: "text", text: "No microservices installed to check." }
+        {
+          type: "text",
+          text: JSON.stringify(results.map((m) => ({
+            name: m.name,
+            package: m.package,
+            description: m.description,
+            category: m.category,
+            tags: m.tags
+          })), null, 2)
+        }
       ]
     };
-  }
-  const report = installed.map((m) => {
-    const missingRequired = m.requiredEnv.filter((env) => !process.env[env]);
-    const missingOptional = (m.optionalEnv ?? []).filter((env) => !process.env[env]);
+  });
+  server.registerTool("install_microservice", {
+    title: "Install Microservice",
+    description: "Install a microservice globally via bun install -g.",
+    inputSchema: { name: exports_external.string(), force: exports_external.boolean().optional() }
+  }, async ({ name, force }) => {
+    const result = installMicroservice(name, { force });
     return {
-      name: m.name,
-      ok: missingRequired.length === 0,
-      missing_required: missingRequired,
-      missing_optional: missingOptional
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }
+      ]
     };
   });
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({
-          summary: {
-            installed: installed.length,
-            total_missing_required: report.reduce((acc, r) => acc + r.missing_required.length, 0),
-            all_ok: report.every((r) => r.ok)
-          },
-          services: report
-        }, null, 2)
-      }
-    ]
-  };
-});
-server.registerTool("scaffold_microservice", {
-  title: "Scaffold Microservice",
-  description: "Scaffold a new microservice from the _template directory.",
-  inputSchema: {
-    name: exports_external.string().describe("The name of the new microservice (lowercase, dashes only)")
-  }
-}, async ({ name }) => {
-  if (!/^[a-z0-9-]+$/.test(name)) {
+  server.registerTool("microservice_status", {
+    title: "Microservice Status",
+    description: "Check if a microservice is installed and get its version.",
+    inputSchema: { name: exports_external.string().optional() }
+  }, async ({ name }) => {
+    if (name) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(getMicroserviceStatus(name), null, 2)
+          }
+        ]
+      };
+    }
+    const statuses = MICROSERVICES.map((m) => getMicroserviceStatus(m.name));
+    return {
+      content: [{ type: "text", text: JSON.stringify(statuses, null, 2) }]
+    };
+  });
+  server.registerTool("run_microservice_command", {
+    title: "Run Microservice Command",
+    description: "Run a CLI command on an installed microservice. Example: run migrate, serve, status.",
+    inputSchema: {
+      name: exports_external.string().describe("Microservice name (e.g. 'auth', 'billing')"),
+      args: exports_external.array(exports_external.string()).describe("CLI arguments (e.g. ['migrate'] or ['status'])")
+    }
+  }, async ({ name, args }) => {
+    const result = await runMicroserviceCommand(name, args);
     return {
       content: [
         {
           type: "text",
           text: JSON.stringify({
-            success: false,
-            error: "Name can only contain lowercase letters, numbers, and dashes."
+            success: result.success,
+            exitCode: result.exitCode,
+            stdout: result.stdout,
+            stderr: result.stderr
           }, null, 2)
         }
       ]
     };
-  }
-  try {
-    const fs = await import("fs");
-    const path = await import("path");
-    const cwd = process.cwd();
-    const templateDir = path.join(cwd, "microservices", "_template");
-    const targetDir = path.join(cwd, "microservices", `microservice-${name}`);
-    if (!fs.existsSync(templateDir)) {
+  });
+  server.registerTool("check_env", {
+    title: "Check Environment Variables",
+    description: "Verify if all required and optional environment variables are set for installed microservices.",
+    inputSchema: {}
+  }, async () => {
+    const installed = MICROSERVICES.filter((m) => microserviceExists(m.name));
+    if (installed.length === 0) {
+      return {
+        content: [
+          { type: "text", text: "No microservices installed to check." }
+        ]
+      };
+    }
+    const report = installed.map((m) => {
+      const missingRequired = m.requiredEnv.filter((env) => !process.env[env]);
+      const missingOptional = (m.optionalEnv ?? []).filter((env) => !process.env[env]);
+      return {
+        name: m.name,
+        ok: missingRequired.length === 0,
+        missing_required: missingRequired,
+        missing_optional: missingOptional
+      };
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({
+            summary: {
+              installed: installed.length,
+              total_missing_required: report.reduce((acc, r) => acc + r.missing_required.length, 0),
+              all_ok: report.every((r) => r.ok)
+            },
+            services: report
+          }, null, 2)
+        }
+      ]
+    };
+  });
+  server.registerTool("scaffold_microservice", {
+    title: "Scaffold Microservice",
+    description: "Scaffold a new microservice from the _template directory.",
+    inputSchema: {
+      name: exports_external.string().describe("The name of the new microservice (lowercase, dashes only)")
+    }
+  }, async ({ name }) => {
+    if (!/^[a-z0-9-]+$/.test(name)) {
       return {
         content: [
           {
             type: "text",
             text: JSON.stringify({
               success: false,
-              error: `Template directory not found at ${templateDir}.`
+              error: "Name can only contain lowercase letters, numbers, and dashes."
             }, null, 2)
           }
         ]
       };
     }
-    if (fs.existsSync(targetDir)) {
+    try {
+      const fs = await import("fs");
+      const path = await import("path");
+      const cwd = process.cwd();
+      const templateDir = path.join(cwd, "microservices", "_template");
+      const targetDir = path.join(cwd, "microservices", `microservice-${name}`);
+      if (!fs.existsSync(templateDir)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: `Template directory not found at ${templateDir}.`
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      if (fs.existsSync(targetDir)) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: JSON.stringify({
+                success: false,
+                error: `Target directory already exists at ${targetDir}`
+              }, null, 2)
+            }
+          ]
+        };
+      }
+      fs.cpSync(templateDir, targetDir, { recursive: true });
+      const replaceInFile = (filePath) => {
+        const content = fs.readFileSync(filePath, "utf-8");
+        let updated = content.replace(/__NAME__/g, name.toUpperCase().replace(/-/g, "_"));
+        updated = updated.replace(/__Name__/g, name.charAt(0).toUpperCase() + name.slice(1));
+        updated = updated.replace(/__name__/g, name);
+        fs.writeFileSync(filePath, updated, "utf-8");
+      };
+      const walkAndReplace = (dir) => {
+        const files = fs.readdirSync(dir);
+        for (const file of files) {
+          const filePath = path.join(dir, file);
+          if (fs.statSync(filePath).isDirectory()) {
+            walkAndReplace(filePath);
+          } else {
+            replaceInFile(filePath);
+          }
+        }
+      };
+      walkAndReplace(targetDir);
       return {
         content: [
           {
             type: "text",
             text: JSON.stringify({
-              success: false,
-              error: `Target directory already exists at ${targetDir}`
+              success: true,
+              message: `Created microservices/microservice-${name}`
             }, null, 2)
           }
         ]
       };
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: false, error: String(err) }, null, 2)
+          }
+        ]
+      };
+    }
+  });
+  server.registerTool("init_all_microservices", {
+    title: "Init All Microservices",
+    description: "Run migrations and confirm setup for all installed microservices.",
+    inputSchema: { db: exports_external.string().describe("PostgreSQL connection URL") }
+  }, async ({ db }) => {
+    process.env.DATABASE_URL = db;
+    const installed = MICROSERVICES.filter((m) => microserviceExists(m.name));
+    if (installed.length === 0) {
+      return {
+        content: [
+          { type: "text", text: "No microservices installed to init." }
+        ]
+      };
+    }
+    const results = [];
+    let hasErrors = false;
+    for (const m of installed) {
+      const res = await runMicroserviceCommand(m.name, ["init", "--db", db]);
+      results.push({
+        name: m.name,
+        success: res.success,
+        output: res.stdout || res.stderr
+      });
+      if (!res.success)
+        hasErrors = true;
     }
-    fs.cpSync(templateDir, targetDir, { recursive: true });
-    const replaceInFile = (filePath) => {
-      const content = fs.readFileSync(filePath, "utf-8");
-      let updated = content.replace(/__NAME__/g, name.toUpperCase().replace(/-/g, "_"));
-      updated = updated.replace(/__Name__/g, name.charAt(0).toUpperCase() + name.slice(1));
-      updated = updated.replace(/__name__/g, name);
-      fs.writeFileSync(filePath, updated, "utf-8");
-    };
-    const walkAndReplace = (dir) => {
-      const files = fs.readdirSync(dir);
-      for (const file of files) {
-        const filePath = path.join(dir, file);
-        if (fs.statSync(filePath).isDirectory()) {
-          walkAndReplace(filePath);
-        } else {
-          replaceInFile(filePath);
-        }
-      }
-    };
-    walkAndReplace(targetDir);
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify({
-            success: true,
-            message: `Created microservices/microservice-${name}`
-          }, null, 2)
+          text: JSON.stringify({ success: !hasErrors, initialized: installed.length, results }, null, 2)
         }
       ]
     };
-  } catch (err) {
+  });
+  server.registerTool("migrate_all_microservices", {
+    title: "Migrate All Microservices",
+    description: "Run database migrations for all installed microservices.",
+    inputSchema: {
+      db: exports_external.string().optional().describe("PostgreSQL connection URL (overrides DATABASE_URL)")
+    }
+  }, async ({ db }) => {
+    if (db)
+      process.env.DATABASE_URL = db;
+    const installed = MICROSERVICES.filter((m) => microserviceExists(m.name));
+    if (installed.length === 0) {
+      return {
+        content: [
+          { type: "text", text: "No microservices installed to migrate." }
+        ]
+      };
+    }
+    const results = [];
+    let hasErrors = false;
+    for (const m of installed) {
+      const res = await runMicroserviceCommand(m.name, ["migrate"]);
+      results.push({
+        name: m.name,
+        success: res.success,
+        output: res.stdout || res.stderr
+      });
+      if (!res.success)
+        hasErrors = true;
+    }
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify({ success: false, error: String(err) }, null, 2)
+          text: JSON.stringify({ success: !hasErrors, migrated: installed.length, results }, null, 2)
         }
       ]
     };
-  }
-});
-server.registerTool("init_all_microservices", {
-  title: "Init All Microservices",
-  description: "Run migrations and confirm setup for all installed microservices.",
-  inputSchema: { db: exports_external.string().describe("PostgreSQL connection URL") }
-}, async ({ db }) => {
-  process.env.DATABASE_URL = db;
-  const installed = MICROSERVICES.filter((m) => microserviceExists(m.name));
-  if (installed.length === 0) {
-    return {
-      content: [
-        { type: "text", text: "No microservices installed to init." }
-      ]
-    };
-  }
-  const results = [];
-  let hasErrors = false;
-  for (const m of installed) {
-    const res = await runMicroserviceCommand(m.name, ["init", "--db", db]);
-    results.push({
-      name: m.name,
-      success: res.success,
-      output: res.stdout || res.stderr
-    });
-    if (!res.success)
-      hasErrors = true;
-  }
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({ success: !hasErrors, initialized: installed.length, results }, null, 2)
-      }
-    ]
-  };
-});
-server.registerTool("migrate_all_microservices", {
-  title: "Migrate All Microservices",
-  description: "Run database migrations for all installed microservices.",
-  inputSchema: {
-    db: exports_external.string().optional().describe("PostgreSQL connection URL (overrides DATABASE_URL)")
-  }
-}, async ({ db }) => {
-  if (db)
-    process.env.DATABASE_URL = db;
-  const installed = MICROSERVICES.filter((m) => microserviceExists(m.name));
-  if (installed.length === 0) {
-    return {
-      content: [
-        { type: "text", text: "No microservices installed to migrate." }
-      ]
-    };
-  }
-  const results = [];
-  let hasErrors = false;
-  for (const m of installed) {
-    const res = await runMicroserviceCommand(m.name, ["migrate"]);
-    results.push({
-      name: m.name,
-      success: res.success,
-      output: res.stdout || res.stderr
-    });
-    if (!res.success)
-      hasErrors = true;
-  }
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({ success: !hasErrors, migrated: installed.length, results }, null, 2)
+  });
+  server.registerTool("serve_all_microservices", {
+    title: "Serve All Microservices",
+    description: "Start HTTP servers for all installed microservices. NOTE: This will run them in the background. It is highly recommended to run this directly in your terminal if you need to view live logs.",
+    inputSchema: {
+      db: exports_external.string().optional().describe("PostgreSQL connection URL (overrides DATABASE_URL)")
+    }
+  }, async ({ db }) => {
+    if (db)
+      process.env.DATABASE_URL = db;
+    const installed = MICROSERVICES.filter((m) => microserviceExists(m.name));
+    if (installed.length === 0) {
+      return {
+        content: [
+          { type: "text", text: "No microservices installed to serve." }
+        ]
+      };
+    }
+    try {
+      const { spawn } = await import("child_process");
+      const servicesStarted = [];
+      for (const m of installed) {
+        const proc = spawn(m.binary, ["serve"], {
+          env: process.env,
+          stdio: "ignore",
+          detached: true
+        });
+        proc.unref();
+        servicesStarted.push(m.name);
       }
-    ]
-  };
-});
-server.registerTool("serve_all_microservices", {
-  title: "Serve All Microservices",
-  description: "Start HTTP servers for all installed microservices. NOTE: This will run them in the background. It is highly recommended to run this directly in your terminal if you need to view live logs.",
-  inputSchema: {
-    db: exports_external.string().optional().describe("PostgreSQL connection URL (overrides DATABASE_URL)")
-  }
-}, async ({ db }) => {
-  if (db)
-    process.env.DATABASE_URL = db;
-  const installed = MICROSERVICES.filter((m) => microserviceExists(m.name));
-  if (installed.length === 0) {
-    return {
-      content: [
-        { type: "text", text: "No microservices installed to serve." }
-      ]
-    };
-  }
-  try {
-    const { spawn } = await import("child_process");
-    const servicesStarted = [];
-    for (let i = 0;i < installed.length; i++) {
-      const m = installed[i];
-      const proc = spawn(m.binary, ["serve"], {
-        env: process.env,
-        stdio: "ignore",
-        detached: true
-      });
-      proc.unref();
-      servicesStarted.push(m.name);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({
+              success: true,
+              started: servicesStarted.length,
+              services: servicesStarted,
+              note: "Processes have been detached and are running in the background."
+            }, null, 2)
+          }
+        ]
+      };
+    } catch (err) {
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify({ success: false, error: String(err) }, null, 2)
+          }
+        ]
+      };
     }
+  });
+  server.registerTool("remove_microservice", {
+    title: "Remove Microservice",
+    description: "Uninstall a microservice global package.",
+    inputSchema: { name: exports_external.string() }
+  }, async ({ name }) => {
+    const ok = removeMicroservice(name);
     return {
       content: [
-        {
-          type: "text",
-          text: JSON.stringify({
-            success: true,
-            started: servicesStarted.length,
-            services: servicesStarted,
-            note: "Processes have been detached and are running in the background."
-          }, null, 2)
-        }
+        { type: "text", text: JSON.stringify({ removed: ok, name }, null, 2) }
       ]
     };
-  } catch (err) {
+  });
+  server.registerTool("get_microservice_info", {
+    title: "Get Microservice Info",
+    description: "Get detailed info about a microservice including schema, required env vars, and tags.",
+    inputSchema: { name: exports_external.string() }
+  }, async ({ name }) => {
+    const m = getMicroservice(name);
+    if (!m)
+      return {
+        content: [{ type: "text", text: `Unknown microservice: ${name}` }]
+      };
     return {
       content: [
         {
           type: "text",
-          text: JSON.stringify({ success: false, error: String(err) }, null, 2)
+          text: JSON.stringify({ ...m, installed: microserviceExists(name) }, null, 2)
         }
       ]
     };
-  }
-});
-server.registerTool("remove_microservice", {
-  title: "Remove Microservice",
-  description: "Uninstall a microservice global package.",
-  inputSchema: { name: exports_external.string() }
-}, async ({ name }) => {
-  const ok = removeMicroservice(name);
-  return {
-    content: [
-      { type: "text", text: JSON.stringify({ removed: ok, name }, null, 2) }
-    ]
-  };
-});
-server.registerTool("get_microservice_info", {
-  title: "Get Microservice Info",
-  description: "Get detailed info about a microservice including schema, required env vars, and tags.",
-  inputSchema: { name: exports_external.string() }
-}, async ({ name }) => {
-  const m = getMicroservice(name);
-  if (!m)
-    return {
-      content: [{ type: "text", text: `Unknown microservice: ${name}` }]
-    };
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify({ ...m, installed: microserviceExists(name) }, null, 2)
-      }
-    ]
-  };
-});
+  });
+  return server;
+}
 async function main() {
+  if (hasFlag("--help", "-h")) {
+    printHelp();
+    return;
+  }
+  if (hasFlag("--version", "-V")) {
+    process.stdout.write(`${getPackageVersion()}
+`);
+    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;
+  }
+  const server = buildServer();
   const transport = new StdioServerTransport;
   await server.connect(transport);
 }
 main().catch(console.error);
+export {
+  buildServer
+};