@askrjs/node 0.0.1 → 0.0.2

package/dist/index.d.ts

@@ -1,7 +1,6 @@
 import { IncomingMessage, Server, ServerResponse } from "node:http";
 import { ServerApp } from "@askrjs/server";
 import { AddressInfo } from "node:net";
-
 //#region src/contracts.d.ts
 interface NodeHandlerOptions {
   baseUrl?: string;
@@ -12,6 +11,17 @@ interface ListenOptions {
   backlog?: number;
   signal?: AbortSignal;
 }
+interface ServeOptions extends ListenOptions {
+  readonly assets?: {
+    readonly root: string;
+  };
+  readonly signals?: false | readonly NodeJS.Signals[];
+}
+interface ServedApplication {
+  readonly server: import("node:http").Server;
+  readonly url: string;
+  close(): Promise<void>;
+}
 type ConnectNext = (error?: unknown) => void;
 type NodeHandler = (request: IncomingMessage, response: ServerResponse, next?: ConnectNext) => void;
 //#endregion
@@ -24,5 +34,10 @@ type ListeningServer = Server & {
 };
 declare function listen(app: ServerApp, options?: ListenOptions): Promise<ListeningServer>;
 //#endregion
-export { ConnectNext, ListenOptions, ListeningServer, NodeHandler, NodeHandlerOptions, createNodeHandler, listen };
+//#region src/serve.d.ts
+declare function serve(app: ServerApp & {
+  close?: () => void | Promise<void>;
+}, options?: ServeOptions): Promise<ServedApplication>;
+//#endregion
+export { ConnectNext, ListenOptions, ListeningServer, NodeHandler, NodeHandlerOptions, ServeOptions, ServedApplication, createNodeHandler, listen, serve };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,5 +1,8 @@
 import { Readable } from "node:stream";
 import { createServer } from "node:http";
+import { createReadStream } from "node:fs";
+import { stat } from "node:fs/promises";
+import { extname, resolve, sep } from "node:path";
 //#region src/request.ts
 function requestHeaders(request) {
 	const headers = new Headers();
@@ -145,6 +148,124 @@ function listen(app, options = {}) {
 	});
 }
 //#endregion
-export { createNodeHandler, listen };
+//#region src/serve.ts
+const mimeTypes = {
+	".css": "text/css; charset=utf-8",
+	".html": "text/html; charset=utf-8",
+	".ico": "image/x-icon",
+	".jpeg": "image/jpeg",
+	".jpg": "image/jpeg",
+	".js": "text/javascript; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".mjs": "text/javascript; charset=utf-8",
+	".png": "image/png",
+	".svg": "image/svg+xml",
+	".webp": "image/webp",
+	".woff": "font/woff",
+	".woff2": "font/woff2"
+};
+function isAssetPath(pathname) {
+	return extname(pathname) !== "";
+}
+async function serve(app, options = {}) {
+	const root = options.assets ? resolve(options.assets.root) : void 0;
+	const applicationHandler = createNodeHandler({ async fetch(request) {
+		const result = await app.fetch(request);
+		if (!result.headers.has("cache-control") && result.headers.get("content-type")?.includes("text/html")) {
+			const headers = new Headers(result.headers);
+			headers.set("cache-control", "no-cache");
+			return new Response(result.body, {
+				status: result.status,
+				statusText: result.statusText,
+				headers
+			});
+		}
+		return result;
+	} });
+	const server = createServer(async (request, response) => {
+		let pathname;
+		try {
+			pathname = decodeURIComponent(new URL(request.url ?? "/", "http://askr.local").pathname);
+		} catch {
+			response.writeHead(400, { "content-type": "text/plain; charset=utf-8" }).end("Bad Request");
+			return;
+		}
+		const method = request.method ?? "GET";
+		if (root && (method === "GET" || method === "HEAD") && isAssetPath(pathname)) {
+			const extension = extname(pathname).toLowerCase();
+			const candidate = resolve(root, `.${pathname}`);
+			const inside = candidate.startsWith(`${root}${sep}`);
+			let file;
+			if (inside && extension !== ".map") try {
+				file = await stat(candidate);
+			} catch {
+				file = void 0;
+			}
+			if (!file?.isFile()) {
+				response.writeHead(404, {
+					"content-type": "text/plain; charset=utf-8",
+					"x-content-type-options": "nosniff"
+				}).end("Not Found");
+				return;
+			}
+			response.writeHead(200, {
+				"content-type": mimeTypes[extension] ?? "application/octet-stream",
+				"content-length": Number(file.size),
+				"cache-control": pathname.startsWith("/assets/") && /-[A-Za-z0-9_-]{8,}\.[^.]+$/.test(pathname) ? "public, max-age=31536000, immutable" : "no-cache",
+				"x-content-type-options": "nosniff"
+			});
+			if (method === "HEAD") response.end();
+			else createReadStream(candidate).pipe(response);
+			return;
+		}
+		applicationHandler(request, response);
+	});
+	let closing;
+	const signals = options.signals === false ? [] : options.signals ?? ["SIGINT", "SIGTERM"];
+	const removeListeners = () => {
+		options.signal?.removeEventListener("abort", shutdown);
+		for (const signal of signals) process.removeListener(signal, shutdown);
+	};
+	const close = () => closing ??= new Promise((resolveClose, rejectClose) => {
+		removeListeners();
+		const finish = async (serverError) => {
+			try {
+				await app.close?.();
+				if (serverError) rejectClose(serverError);
+				else resolveClose();
+			} catch (error) {
+				rejectClose(error);
+			}
+		};
+		if (!server.listening) finish();
+		else server.close((error) => void finish(error));
+	});
+	const shutdown = () => void close().catch(() => void 0);
+	options.signal?.addEventListener("abort", shutdown, { once: true });
+	for (const signal of signals) process.once(signal, shutdown);
+	await new Promise((resolveListen, rejectListen) => {
+		server.once("error", rejectListen);
+		server.listen(options.port ?? 0, options.host ?? "127.0.0.1", options.backlog, () => {
+			server.removeListener("error", rejectListen);
+			resolveListen();
+		});
+	}).catch((error) => {
+		removeListeners();
+		throw error;
+	});
+	const address = server.address();
+	if (!address || typeof address === "string") {
+		await close();
+		throw new Error("serve requires a TCP address.");
+	}
+	const host = options.host ?? "127.0.0.1";
+	return Object.freeze({
+		server,
+		url: `http://${host}:${address.port}`,
+		close
+	});
+}
+//#endregion
+export { createNodeHandler, listen, serve };
 
 //# sourceMappingURL=index.js.map

package/dist/mcp.d.ts

@@ -0,0 +1,21 @@
+import { Readable, Writable } from "node:stream";
+import { AuthContext } from "@askrjs/auth";
+import { McpServer } from "@askrjs/server/mcp";
+//#region src/mcp.d.ts
+interface McpStdioOptions<Dependencies = undefined> {
+  dependencies: Dependencies;
+  input?: Readable;
+  output?: Writable;
+  diagnostics?: Writable;
+  signal?: AbortSignal;
+  auth?: AuthContext | ((environment: NodeJS.ProcessEnv) => AuthContext | Promise<AuthContext>);
+  environment?: NodeJS.ProcessEnv;
+}
+interface McpStdioConnection {
+  readonly closed: Promise<void>;
+  close(): Promise<void>;
+}
+declare function connectMcpStdio<Dependencies>(mcp: McpServer<Dependencies>, options: McpStdioOptions<Dependencies>): McpStdioConnection;
+//#endregion
+export { McpStdioConnection, McpStdioOptions, connectMcpStdio };
+//# sourceMappingURL=mcp.d.ts.map

package/dist/mcp.js

@@ -0,0 +1,97 @@
+import { createInterface } from "node:readline";
+//#region src/mcp.ts
+const anonymous = Object.freeze({
+	authenticated: false,
+	principal: null,
+	session: null,
+	tenant: null
+});
+function connectMcpStdio(mcp, options) {
+	const input = options.input ?? process.stdin;
+	const output = options.output ?? process.stdout;
+	const diagnostics = options.diagnostics ?? process.stderr;
+	const lines = createInterface({
+		input,
+		crlfDelay: Infinity,
+		terminal: false
+	});
+	const controllers = /* @__PURE__ */ new Map();
+	const sessionId = crypto.randomUUID();
+	let finish;
+	const closed = new Promise((resolve) => {
+		finish = resolve;
+	});
+	let ended = false;
+	const write = (message) => new Promise((resolve, reject) => {
+		output.write(`${JSON.stringify(message)}\n`, (error) => error ? reject(error) : resolve());
+	});
+	const close = async () => {
+		if (ended) return closed;
+		ended = true;
+		lines.close();
+		for (const controller of controllers.values()) controller.abort();
+		controllers.clear();
+		mcp.terminateSession(sessionId);
+		finish();
+		return closed;
+	};
+	options.signal?.addEventListener("abort", () => void close(), { once: true });
+	lines.on("line", (line) => {
+		(async () => {
+			let message;
+			try {
+				message = JSON.parse(line);
+			} catch {
+				await write({
+					jsonrpc: "2.0",
+					id: null,
+					error: {
+						code: -32700,
+						message: "Parse error"
+					}
+				});
+				return;
+			}
+			if (message && typeof message === "object") {
+				const value = message;
+				if (value.method === "notifications/cancelled" && value.params && typeof value.params === "object") {
+					const requestId = value.params.requestId;
+					if (typeof requestId === "string" || typeof requestId === "number") controllers.get(requestId)?.abort();
+				}
+				const id = value.id;
+				const controller = typeof id === "string" || typeof id === "number" ? new AbortController() : void 0;
+				if (controller && (typeof id === "string" || typeof id === "number")) controllers.set(id, controller);
+				try {
+					const environment = options.environment ?? process.env;
+					const auth = typeof options.auth === "function" ? await options.auth(environment) : options.auth ?? anonymous;
+					const result = await mcp.handle(message, {
+						dependencies: options.dependencies,
+						auth,
+						transport: "stdio",
+						sessionId,
+						supportsPush: true,
+						signal: controller?.signal ?? options.signal,
+						send: write
+					});
+					if (result !== void 0) await write(result);
+				} finally {
+					if (controller && id !== void 0) controllers.delete(id);
+				}
+			}
+		})().catch((error) => diagnostics.write(`MCP stdio error: ${error instanceof Error ? error.message : String(error)}\n`));
+	});
+	lines.once("close", () => {
+		if (!ended) {
+			ended = true;
+			finish();
+		}
+	});
+	return {
+		closed,
+		close
+	};
+}
+//#endregion
+export { connectMcpStdio };
+
+//# sourceMappingURL=mcp.js.map

package/package.json

@@ -1,22 +1,47 @@
 {
   "name": "@askrjs/node",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Node http adapter for @askrjs/server",
-  "keywords": ["askr", "http", "node", "server"],
+  "keywords": [
+    "askr",
+    "http",
+    "node",
+    "server"
+  ],
   "homepage": "https://github.com/askrjs/askr-node#readme",
-  "bugs": { "url": "https://github.com/askrjs/askr-node/issues" },
-  "repository": { "type": "git", "url": "git+https://github.com/askrjs/askr-node.git" },
-  "author": { "name": "askrjs", "url": "https://github.com/askrjs" },
+  "bugs": {
+    "url": "https://github.com/askrjs/askr-node/issues"
+  },
   "license": "Apache-2.0",
+  "author": {
+    "name": "askrjs",
+    "url": "https://github.com/askrjs"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/askrjs/askr-node.git"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
-    ".": { "types": "./dist/index.d.ts", "import": "./dist/index.js" },
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./mcp": {
+      "types": "./dist/mcp.d.ts",
+      "import": "./dist/mcp.js"
+    },
     "./package.json": "./package.json"
   },
-  "files": ["dist/**/*.js", "dist/**/*.d.ts"],
-  "publishConfig": { "access": "public" },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "build": "vp pack",
     "fmt": "vp fmt .",
@@ -29,7 +54,18 @@
     "prepack": "npm run build",
     "prepublishOnly": "npm run check"
   },
-  "dependencies": { "@askrjs/server": ">=0.0.1 <0.1.0" },
-  "devDependencies": { "@types/node": "^26.0.0", "publint": "^0.3.21", "typescript": "^6.0.0", "vitest": "^4.0.0", "vite-plus": "^0.2.4" },
-  "engines": { "node": ">=18" }
+  "dependencies": {
+    "@askrjs/auth": ">=0.0.1 <0.1.0",
+    "@askrjs/server": ">=0.0.1 <0.1.0"
+  },
+  "devDependencies": {
+    "@types/node": "^26.0.0",
+    "publint": "^0.3.21",
+    "typescript": "^6.0.0",
+    "vite-plus": "^0.2.4",
+    "vitest": "^4.0.0"
+  },
+  "engines": {
+    "node": ">=18"
+  }
 }