@corsenai/corsen-context-astro 1.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Corsen AI
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# @corsenai/corsen-context-astro
+
+Astro adapter for **[Corsen Context](https://github.com/CorsenAI/corsen-context)** — drop-in API route handlers for the MCP endpoint and `llms.txt`, with built-in auth, rate limiting, CORS, and security headers. Uses Astro's `clientAddress` for accurate rate limiting.
+
+> Requires Astro SSR (`output: 'server'` or `'hybrid'`).
+
+```bash
+npm install @corsenai/corsen-context @corsenai/corsen-context-astro
+```
+
+**MCP endpoint** — `src/pages/v1/mcp.ts`:
+
+```typescript
+import { createMCPHandler } from '@corsenai/corsen-context-astro';
+import { siteProvider } from '../../lib/corsen-provider';
+
+export const { POST, OPTIONS } = createMCPHandler(
+  { siteUrl: import.meta.env.SITE ?? 'https://example.com' },
+  siteProvider,
+);
+```
+
+**llms.txt** — `src/pages/llms.txt.ts`:
+
+```typescript
+import { createLlmsTxtHandler } from '@corsenai/corsen-context-astro';
+import { siteProvider } from '../lib/corsen-provider';
+
+export const GET = createLlmsTxtHandler({ siteUrl: import.meta.env.SITE }, siteProvider);
+```
+
+For production (multi-instance), pass a Redis cache and rate-limit store via the third `options` argument (`{ cache, rateLimitStore, logger }`).
+
+- **Full docs:** https://github.com/CorsenAI/corsen-context#readme
+- **License:** MIT

package/dist/index.d.mts

@@ -0,0 +1,45 @@
+import { CacheDriver, RateLimitStore, Logger, CorsenContextConfig, ContentProvider } from '@corsenai/corsen-context';
+export { CacheDriver, ContentProvider, CorsenContextConfig, Logger, RateLimitStore } from '@corsenai/corsen-context';
+
+/**
+ * Optional production wiring for the Astro handlers — inject the same
+ * distributed cache, rate-limit store, and logger the core supports.
+ */
+interface HandlerOptions {
+    cache?: CacheDriver;
+    rateLimitStore?: RateLimitStore;
+    logger?: Logger;
+}
+/**
+ * The subset of Astro's APIContext the handlers use. `clientAddress` is the real
+ * socket peer address the Astro server adapter resolves — better than a header
+ * guess for rate limiting.
+ */
+interface AstroContext {
+    request: Request;
+    clientAddress?: string;
+}
+/**
+ * Creates an Astro API route handler for the MCP endpoint (POST /v1/mcp).
+ *
+ * Usage (src/pages/v1/mcp.ts):
+ * ```ts
+ * import { createMCPHandler } from '@corsenai/corsen-context-astro';
+ * import { siteProvider } from '../../lib/corsen-provider';
+ *
+ * export const { POST, OPTIONS } = createMCPHandler(
+ *   { siteUrl: import.meta.env.SITE ?? 'https://example.com' },
+ *   siteProvider,
+ * );
+ * ```
+ */
+declare function createMCPHandler(config: CorsenContextConfig, provider: ContentProvider, options?: HandlerOptions): {
+    POST: (context: AstroContext) => Promise<Response>;
+    OPTIONS: (context: AstroContext) => Promise<Response>;
+};
+/** Creates an Astro GET handler that serves /llms.txt. */
+declare function createLlmsTxtHandler(config: CorsenContextConfig, provider: ContentProvider, options?: HandlerOptions): () => Promise<Response>;
+/** Creates an Astro GET handler that serves /llms-full.txt. */
+declare function createLlmsFullTxtHandler(config: CorsenContextConfig, provider: ContentProvider, options?: HandlerOptions): () => Promise<Response>;
+
+export { type AstroContext, type HandlerOptions, createLlmsFullTxtHandler, createLlmsTxtHandler, createMCPHandler };

package/dist/index.d.ts

@@ -0,0 +1,45 @@
+import { CacheDriver, RateLimitStore, Logger, CorsenContextConfig, ContentProvider } from '@corsenai/corsen-context';
+export { CacheDriver, ContentProvider, CorsenContextConfig, Logger, RateLimitStore } from '@corsenai/corsen-context';
+
+/**
+ * Optional production wiring for the Astro handlers — inject the same
+ * distributed cache, rate-limit store, and logger the core supports.
+ */
+interface HandlerOptions {
+    cache?: CacheDriver;
+    rateLimitStore?: RateLimitStore;
+    logger?: Logger;
+}
+/**
+ * The subset of Astro's APIContext the handlers use. `clientAddress` is the real
+ * socket peer address the Astro server adapter resolves — better than a header
+ * guess for rate limiting.
+ */
+interface AstroContext {
+    request: Request;
+    clientAddress?: string;
+}
+/**
+ * Creates an Astro API route handler for the MCP endpoint (POST /v1/mcp).
+ *
+ * Usage (src/pages/v1/mcp.ts):
+ * ```ts
+ * import { createMCPHandler } from '@corsenai/corsen-context-astro';
+ * import { siteProvider } from '../../lib/corsen-provider';
+ *
+ * export const { POST, OPTIONS } = createMCPHandler(
+ *   { siteUrl: import.meta.env.SITE ?? 'https://example.com' },
+ *   siteProvider,
+ * );
+ * ```
+ */
+declare function createMCPHandler(config: CorsenContextConfig, provider: ContentProvider, options?: HandlerOptions): {
+    POST: (context: AstroContext) => Promise<Response>;
+    OPTIONS: (context: AstroContext) => Promise<Response>;
+};
+/** Creates an Astro GET handler that serves /llms.txt. */
+declare function createLlmsTxtHandler(config: CorsenContextConfig, provider: ContentProvider, options?: HandlerOptions): () => Promise<Response>;
+/** Creates an Astro GET handler that serves /llms-full.txt. */
+declare function createLlmsFullTxtHandler(config: CorsenContextConfig, provider: ContentProvider, options?: HandlerOptions): () => Promise<Response>;
+
+export { type AstroContext, type HandlerOptions, createLlmsFullTxtHandler, createLlmsTxtHandler, createMCPHandler };

package/dist/index.js

@@ -0,0 +1,201 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createLlmsFullTxtHandler: () => createLlmsFullTxtHandler,
+  createLlmsTxtHandler: () => createLlmsTxtHandler,
+  createMCPHandler: () => createMCPHandler
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/handlers.ts
+var import_corsen_context = require("@corsenai/corsen-context");
+var cachedInstances = /* @__PURE__ */ new WeakMap();
+function getInstance(config, provider, cache) {
+  let providerInstances = cachedInstances.get(provider);
+  if (!providerInstances) {
+    providerInstances = /* @__PURE__ */ new Map();
+    cachedInstances.set(provider, providerInstances);
+  }
+  const configKey = stableStringify(config);
+  let instance = providerInstances.get(configKey);
+  if (!instance) {
+    instance = new import_corsen_context.CorsenContext(config, provider, cache);
+    providerInstances.set(configKey, instance);
+  }
+  return instance;
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value) ?? "undefined";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const record = value;
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function getClientIp(context, trustProxy) {
+  if (trustProxy) {
+    const cfIp = context.request.headers.get("cf-connecting-ip");
+    if (cfIp) return cfIp.trim();
+    const realIp = context.request.headers.get("x-real-ip");
+    if (realIp) return realIp.trim();
+    const xff = context.request.headers.get("x-forwarded-for");
+    if (xff) {
+      const first = xff.split(",")[0]?.trim();
+      if (first) return first;
+    }
+  }
+  return context.clientAddress || "unknown";
+}
+function getApiKey(request) {
+  return request.headers.get("x-mcp-key") || request.headers.get("authorization")?.replace("Bearer ", "") || void 0;
+}
+async function readBoundedText(request) {
+  const body = request.body;
+  if (!body || typeof body.getReader !== "function") {
+    const text = await request.text();
+    return new TextEncoder().encode(text).length > import_corsen_context.MAX_BODY_SIZE ? null : text;
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) {
+      total += value.byteLength;
+      if (total > import_corsen_context.MAX_BODY_SIZE) {
+        await reader.cancel();
+        return null;
+      }
+      chunks.push(value);
+    }
+  }
+  const merged = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(merged);
+}
+function createMCPHandler(config, provider, options) {
+  const trustProxy = config.security?.trustProxy ?? false;
+  function createServer(instance) {
+    return instance.createMCPServer({
+      rateLimitStore: options?.rateLimitStore,
+      logger: options?.logger
+    });
+  }
+  async function POST(context) {
+    const { request } = context;
+    const instance = getInstance(config, provider, options?.cache);
+    const server = createServer(instance);
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(server.getSecurityHeaders())) {
+      headers.set(key, value);
+    }
+    headers.set("Content-Type", "application/json");
+    const origin = request.headers.get("origin") || void 0;
+    for (const [key, value] of Object.entries(server.getCorsHeaders(origin))) {
+      headers.set(key, value);
+    }
+    const clientIp = getClientIp(context, trustProxy);
+    const apiKey = getApiKey(request);
+    const rateLimit = await server.checkRateLimit(clientIp, apiKey);
+    for (const [key, value] of Object.entries(rateLimit.headers)) {
+      headers.set(key, value);
+    }
+    if (!rateLimit.allowed) {
+      return new Response(
+        JSON.stringify({ jsonrpc: "2.0", error: { code: -32e3, message: "Rate limit exceeded" }, id: null }),
+        { status: 429, headers }
+      );
+    }
+    if (!server.checkAuth(apiKey)) {
+      return new Response(
+        JSON.stringify({ jsonrpc: "2.0", error: { code: -32e3, message: "Unauthorized" }, id: null }),
+        { status: 401, headers }
+      );
+    }
+    const raw = await readBoundedText(request);
+    if (raw === null) {
+      return new Response(
+        JSON.stringify({ jsonrpc: "2.0", error: { code: -32600, message: "Request body too large" }, id: null }),
+        { status: 413, headers }
+      );
+    }
+    let body;
+    try {
+      body = JSON.parse(raw);
+    } catch {
+      return new Response(
+        JSON.stringify({ jsonrpc: "2.0", error: { code: -32700, message: "Parse error" }, id: null }),
+        { status: 400, headers }
+      );
+    }
+    const result = await server.handleRequest(body, clientIp, apiKey, { skipRateLimit: true });
+    if (result === null) {
+      return new Response(null, { status: 204, headers });
+    }
+    return new Response(JSON.stringify(result), { status: 200, headers });
+  }
+  async function OPTIONS(context) {
+    const instance = getInstance(config, provider, options?.cache);
+    const server = createServer(instance);
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(server.getSecurityHeaders())) {
+      headers.set(key, value);
+    }
+    const origin = context.request.headers.get("origin") || void 0;
+    for (const [key, value] of Object.entries(server.getCorsHeaders(origin))) {
+      headers.set(key, value);
+    }
+    return new Response(null, { status: 204, headers });
+  }
+  return { POST, OPTIONS };
+}
+function createLlmsTxtHandler(config, provider, options) {
+  return async function GET() {
+    const text = await getInstance(config, provider, options?.cache).generateLlmsTxt();
+    const headers = new Headers(import_corsen_context.SECURITY_HEADERS);
+    headers.set("Content-Type", "text/plain; charset=utf-8");
+    headers.set("Cache-Control", "public, max-age=3600, s-maxage=3600");
+    return new Response(text, { status: 200, headers });
+  };
+}
+function createLlmsFullTxtHandler(config, provider, options) {
+  return async function GET() {
+    const text = await getInstance(config, provider, options?.cache).generateLlmsFullTxt();
+    const headers = new Headers(import_corsen_context.SECURITY_HEADERS);
+    headers.set("Content-Type", "text/plain; charset=utf-8");
+    headers.set("Cache-Control", "public, max-age=3600, s-maxage=3600");
+    return new Response(text, { status: 200, headers });
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createLlmsFullTxtHandler,
+  createLlmsTxtHandler,
+  createMCPHandler
+});

package/dist/index.mjs

@@ -0,0 +1,176 @@
+// src/handlers.ts
+import {
+  CorsenContext,
+  MAX_BODY_SIZE,
+  SECURITY_HEADERS
+} from "@corsenai/corsen-context";
+var cachedInstances = /* @__PURE__ */ new WeakMap();
+function getInstance(config, provider, cache) {
+  let providerInstances = cachedInstances.get(provider);
+  if (!providerInstances) {
+    providerInstances = /* @__PURE__ */ new Map();
+    cachedInstances.set(provider, providerInstances);
+  }
+  const configKey = stableStringify(config);
+  let instance = providerInstances.get(configKey);
+  if (!instance) {
+    instance = new CorsenContext(config, provider, cache);
+    providerInstances.set(configKey, instance);
+  }
+  return instance;
+}
+function stableStringify(value) {
+  if (value === null || typeof value !== "object") {
+    return JSON.stringify(value) ?? "undefined";
+  }
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+  }
+  const record = value;
+  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableStringify(record[key])}`).join(",")}}`;
+}
+function getClientIp(context, trustProxy) {
+  if (trustProxy) {
+    const cfIp = context.request.headers.get("cf-connecting-ip");
+    if (cfIp) return cfIp.trim();
+    const realIp = context.request.headers.get("x-real-ip");
+    if (realIp) return realIp.trim();
+    const xff = context.request.headers.get("x-forwarded-for");
+    if (xff) {
+      const first = xff.split(",")[0]?.trim();
+      if (first) return first;
+    }
+  }
+  return context.clientAddress || "unknown";
+}
+function getApiKey(request) {
+  return request.headers.get("x-mcp-key") || request.headers.get("authorization")?.replace("Bearer ", "") || void 0;
+}
+async function readBoundedText(request) {
+  const body = request.body;
+  if (!body || typeof body.getReader !== "function") {
+    const text = await request.text();
+    return new TextEncoder().encode(text).length > MAX_BODY_SIZE ? null : text;
+  }
+  const reader = body.getReader();
+  const chunks = [];
+  let total = 0;
+  for (; ; ) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    if (value) {
+      total += value.byteLength;
+      if (total > MAX_BODY_SIZE) {
+        await reader.cancel();
+        return null;
+      }
+      chunks.push(value);
+    }
+  }
+  const merged = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    merged.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(merged);
+}
+function createMCPHandler(config, provider, options) {
+  const trustProxy = config.security?.trustProxy ?? false;
+  function createServer(instance) {
+    return instance.createMCPServer({
+      rateLimitStore: options?.rateLimitStore,
+      logger: options?.logger
+    });
+  }
+  async function POST(context) {
+    const { request } = context;
+    const instance = getInstance(config, provider, options?.cache);
+    const server = createServer(instance);
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(server.getSecurityHeaders())) {
+      headers.set(key, value);
+    }
+    headers.set("Content-Type", "application/json");
+    const origin = request.headers.get("origin") || void 0;
+    for (const [key, value] of Object.entries(server.getCorsHeaders(origin))) {
+      headers.set(key, value);
+    }
+    const clientIp = getClientIp(context, trustProxy);
+    const apiKey = getApiKey(request);
+    const rateLimit = await server.checkRateLimit(clientIp, apiKey);
+    for (const [key, value] of Object.entries(rateLimit.headers)) {
+      headers.set(key, value);
+    }
+    if (!rateLimit.allowed) {
+      return new Response(
+        JSON.stringify({ jsonrpc: "2.0", error: { code: -32e3, message: "Rate limit exceeded" }, id: null }),
+        { status: 429, headers }
+      );
+    }
+    if (!server.checkAuth(apiKey)) {
+      return new Response(
+        JSON.stringify({ jsonrpc: "2.0", error: { code: -32e3, message: "Unauthorized" }, id: null }),
+        { status: 401, headers }
+      );
+    }
+    const raw = await readBoundedText(request);
+    if (raw === null) {
+      return new Response(
+        JSON.stringify({ jsonrpc: "2.0", error: { code: -32600, message: "Request body too large" }, id: null }),
+        { status: 413, headers }
+      );
+    }
+    let body;
+    try {
+      body = JSON.parse(raw);
+    } catch {
+      return new Response(
+        JSON.stringify({ jsonrpc: "2.0", error: { code: -32700, message: "Parse error" }, id: null }),
+        { status: 400, headers }
+      );
+    }
+    const result = await server.handleRequest(body, clientIp, apiKey, { skipRateLimit: true });
+    if (result === null) {
+      return new Response(null, { status: 204, headers });
+    }
+    return new Response(JSON.stringify(result), { status: 200, headers });
+  }
+  async function OPTIONS(context) {
+    const instance = getInstance(config, provider, options?.cache);
+    const server = createServer(instance);
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(server.getSecurityHeaders())) {
+      headers.set(key, value);
+    }
+    const origin = context.request.headers.get("origin") || void 0;
+    for (const [key, value] of Object.entries(server.getCorsHeaders(origin))) {
+      headers.set(key, value);
+    }
+    return new Response(null, { status: 204, headers });
+  }
+  return { POST, OPTIONS };
+}
+function createLlmsTxtHandler(config, provider, options) {
+  return async function GET() {
+    const text = await getInstance(config, provider, options?.cache).generateLlmsTxt();
+    const headers = new Headers(SECURITY_HEADERS);
+    headers.set("Content-Type", "text/plain; charset=utf-8");
+    headers.set("Cache-Control", "public, max-age=3600, s-maxage=3600");
+    return new Response(text, { status: 200, headers });
+  };
+}
+function createLlmsFullTxtHandler(config, provider, options) {
+  return async function GET() {
+    const text = await getInstance(config, provider, options?.cache).generateLlmsFullTxt();
+    const headers = new Headers(SECURITY_HEADERS);
+    headers.set("Content-Type", "text/plain; charset=utf-8");
+    headers.set("Cache-Control", "public, max-age=3600, s-maxage=3600");
+    return new Response(text, { status: 200, headers });
+  };
+}
+export {
+  createLlmsFullTxtHandler,
+  createLlmsTxtHandler,
+  createMCPHandler
+};

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@corsenai/corsen-context-astro",
+  "version": "1.2.0",
+  "description": "Astro adapter for Corsen Context — AI Context Layer with MCP + llms.txt",
+  "author": "Corsen AI <contact@corsen.ai>",
+  "license": "MIT",
+  "homepage": "https://github.com/CorsenAI/corsen-context",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/CorsenAI/corsen-context.git",
+    "directory": "packages/astro-adapter"
+  },
+  "keywords": [
+    "mcp",
+    "llms-txt",
+    "astro",
+    "ai",
+    "corsen"
+  ],
+  "main": "./dist/index.js",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "LICENSE",
+    "README.md"
+  ],
+  "dependencies": {
+    "@corsenai/corsen-context": "1.2.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.3.0",
+    "typescript": "^5.7.0",
+    "vitest": "^2.1.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "bugs": {
+    "url": "https://github.com/CorsenAI/corsen-context/issues"
+  },
+  "sideEffects": false,
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "test": "vitest run",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  }
+}