@aigne/afs-http 1.11.0-beta.3

package/LICENSE.md

@@ -0,0 +1,26 @@
+# Proprietary License
+
+Copyright (c) 2024-2025 ArcBlock, Inc. All Rights Reserved.
+
+This software and associated documentation files (the "Software") are proprietary
+and confidential. Unauthorized copying, modification, distribution, or use of
+this Software, via any medium, is strictly prohibited.
+
+The Software is provided for internal use only within ArcBlock, Inc. and its
+authorized affiliates.
+
+## No License Granted
+
+No license, express or implied, is granted to any party for any purpose.
+All rights are reserved by ArcBlock, Inc.
+
+## Public Artifact Distribution
+
+Portions of this Software may be released publicly under separate open-source
+licenses (such as MIT License) through designated public repositories. Such
+public releases are governed by their respective licenses and do not affect
+the proprietary nature of this repository.
+
+## Contact
+
+For licensing inquiries, contact: legal@arcblock.io

package/README.md

@@ -0,0 +1,318 @@
+# @aigne/afs-http
+
+HTTP Transport Provider for AFS (Agentic File System), allowing transparent mounting of remote AFS providers over HTTP.
+
+## Features
+
+- 🌐 **RPC-style REST API** - Simple POST /rpc endpoint with method parameter
+- 🔄 **Automatic Retry** - Exponential backoff with configurable options
+- 🎯 **Dual-layer Error Codes** - HTTP status codes + CLI error codes for AFS consistency
+- 🔌 **Framework Agnostic** - Web Standard Request/Response API
+- 🚀 **Express/Koa Adapters** - Ready-to-use middleware for popular frameworks
+- 📦 **Type Safe** - Full TypeScript support with Zod validation
+
+## Installation
+
+```bash
+pnpm add @aigne/afs-http
+```
+
+## Quick Start
+
+### Server Side
+
+#### Express
+
+```typescript
+import express from "express";
+import { createAFSExpressHandler } from "@aigne/afs-http";
+import { AFSLocalProvider } from "@aigne/afs-local";
+
+const app = express();
+
+// Create a local AFS provider to expose
+const provider = new AFSLocalProvider({
+  name: "local",
+  rootPath: "./data",
+});
+
+// Mount the AFS HTTP handler
+app.use("/afs", createAFSExpressHandler({ provider }));
+
+app.listen(3000, () => {
+  console.log("AFS HTTP server listening on http://localhost:3000");
+});
+```
+
+#### Koa
+
+```typescript
+import Koa from "koa";
+import { createAFSKoaHandler } from "@aigne/afs-http";
+import { AFSLocalProvider } from "@aigne/afs-local";
+
+const app = new Koa();
+
+const provider = new AFSLocalProvider({
+  name: "local",
+  rootPath: "./data",
+});
+
+app.use(createAFSKoaHandler({ provider }));
+
+app.listen(3000);
+```
+
+#### Custom Framework
+
+```typescript
+import { createAFSHttpHandler } from "@aigne/afs-http";
+import { AFSLocalProvider } from "@aigne/afs-local";
+
+const provider = new AFSLocalProvider({
+  name: "local",
+  rootPath: "./data",
+});
+
+const handler = createAFSHttpHandler({ provider });
+
+// Use with any framework that supports Web Standard Request/Response
+async function handleRequest(request: Request): Promise<Response> {
+  return await handler(request);
+}
+```
+
+### Client Side
+
+```typescript
+import { AFS } from "@aigne/afs";
+import { AFSHttpClient } from "@aigne/afs-http";
+
+// Create HTTP client
+const httpClient = new AFSHttpClient({
+  url: "http://localhost:3000/afs",
+  name: "remote",
+  description: "Remote AFS over HTTP",
+});
+
+// Mount to AFS
+const afs = new AFS();
+afs.mount(httpClient);
+
+// Use like any other AFS provider
+const files = await afs.list("/remote");
+const content = await afs.read("/remote/file.txt");
+await afs.write("/remote/new.txt", "Hello, World!");
+```
+
+## Configuration
+
+### Server Options
+
+```typescript
+interface AFSHttpHandlerOptions {
+  /** AFS provider to expose */
+  provider: AFSModule;
+
+  /** Maximum request body size in bytes (default: 10MB) */
+  maxBodySize?: number;
+
+  /** Enable debug logging (default: false) */
+  debug?: boolean;
+}
+```
+
+### Client Options
+
+```typescript
+interface AFSHttpClientOptions {
+  /** Server URL (e.g., "http://localhost:3000/afs") */
+  url: string;
+
+  /** Provider name for AFS mounting */
+  name: string;
+
+  /** Optional description */
+  description?: string;
+
+  /** Retry configuration */
+  retry?: {
+    maxAttempts?: number;      // Default: 3
+    initialDelay?: number;     // Default: 1000ms
+    maxDelay?: number;         // Default: 10000ms
+    multiplier?: number;       // Default: 2
+  };
+
+  /** Request timeout in milliseconds (default: 30000) */
+  timeout?: number;
+
+  /** Custom fetch implementation */
+  fetch?: typeof fetch;
+}
+```
+
+## API Methods
+
+The HTTP transport supports all standard AFS operations:
+
+- `list(path)` - List files and directories
+- `read(path)` - Read file content
+- `write(path, content, options)` - Write file content
+- `delete(path)` - Delete file or directory
+- `rename(oldPath, newPath)` - Rename/move file or directory
+- `search(path, query, options)` - Search for files
+- `exec(path, input)` - Execute command or script
+
+## Error Handling
+
+The HTTP transport uses dual-layer error codes:
+
+### HTTP Status Codes
+
+- `200 OK` - Success
+- `400 Bad Request` - Invalid request format
+- `404 Not Found` - Resource not found
+- `409 Conflict` - Operation conflict (e.g., file exists)
+- `413 Payload Too Large` - Request body exceeds maxBodySize
+- `500 Internal Server Error` - Server error
+
+### CLI Error Codes
+
+Consistent with AFS CLI tools:
+
+```typescript
+enum AFSErrorCode {
+  OK = 0,
+  NOT_FOUND = 1,
+  PERMISSION_DENIED = 2,
+  CONFLICT = 3,
+  PARTIAL = 4,
+  RUNTIME_ERROR = 5,
+}
+```
+
+## Protocol
+
+The HTTP transport uses a simple RPC-style protocol:
+
+### Request
+
+```http
+POST /rpc HTTP/1.1
+Content-Type: application/json
+
+{
+  "method": "read",
+  "params": {
+    "path": "/file.txt"
+  }
+}
+```
+
+### Response (Success)
+
+```http
+HTTP/1.1 200 OK
+Content-Type: application/json
+
+{
+  "code": 0,
+  "data": {
+    "content": "file content",
+    "mimeType": "text/plain"
+  }
+}
+```
+
+### Response (Error)
+
+```http
+HTTP/1.1 404 Not Found
+Content-Type: application/json
+
+{
+  "code": 1,
+  "error": "File not found: /file.txt"
+}
+```
+
+## Retry Behavior
+
+The client automatically retries failed requests with exponential backoff:
+
+- Retries on network errors and 5xx status codes
+- Does not retry 4xx errors (client errors)
+- Default: 3 attempts with 1s → 2s → 4s delays
+- Configurable via `retry` options
+
+```typescript
+const client = new AFSHttpClient({
+  url: "http://localhost:3000/afs",
+  name: "remote",
+  retry: {
+    maxAttempts: 5,
+    initialDelay: 500,
+    maxDelay: 30000,
+    multiplier: 2,
+  },
+});
+```
+
+## Advanced Usage
+
+### Custom Authentication
+
+Add authentication headers to the client:
+
+```typescript
+class AuthenticatedHttpClient extends AFSHttpClient {
+  async fetch(url: string, options: RequestInit): Promise<Response> {
+    return super.fetch(url, {
+      ...options,
+      headers: {
+        ...options.headers,
+        "Authorization": `Bearer ${process.env.API_TOKEN}`,
+      },
+    });
+  }
+}
+```
+
+### Custom Error Handling
+
+```typescript
+try {
+  const content = await afs.read("/remote/file.txt");
+} catch (error) {
+  if (error instanceof AFSHttpError) {
+    console.error(`HTTP ${error.status}: ${error.message}`);
+    console.error(`AFS Error Code: ${error.code}`);
+  }
+}
+```
+
+## Performance Considerations
+
+- **File Size Limits**: Configure `maxBodySize` based on your needs
+- **Timeouts**: Adjust client timeout for slow networks
+- **Retry Strategy**: Tune retry parameters for your use case
+- **Caching**: Not implemented (prioritizes data consistency)
+
+## Development
+
+```bash
+# Install dependencies
+pnpm install
+
+# Build
+pnpm build
+
+# Run tests
+pnpm test
+
+# Type check
+pnpm check-types
+
+# Lint
+pnpm lint
+```

package/dist/adapters/express.cjs

@@ -0,0 +1,74 @@
+
+//#region src/adapters/express.ts
+/**
+* Collect stream data into a string
+*/
+async function streamToString(stream) {
+	const chunks = [];
+	return new Promise((resolve, reject) => {
+		stream.on("data", (chunk) => chunks.push(chunk));
+		stream.on("error", reject);
+		stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+	});
+}
+/**
+* Convert Express headers to Headers object
+*/
+function convertHeaders(headers) {
+	const result = new Headers();
+	for (const [key, value] of Object.entries(headers)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) for (const v of value) result.append(key, v);
+		else result.set(key, value);
+	}
+	return result;
+}
+/**
+* Express adapter for AFS HTTP handler
+*
+* This adapter converts between Express request/response objects and
+* Web Standard Request/Response objects, handling both scenarios where
+* body parsing middleware is configured and where it isn't.
+*
+* @param handler - The AFS HTTP handler function
+* @returns An Express-compatible request handler
+*
+* @example
+* ```typescript
+* import express from "express";
+* import { createAFSHttpHandler, expressAdapter } from "@aigne/afs-http";
+*
+* const handler = createAFSHttpHandler({ module: provider });
+* const app = express();
+*
+* // Works with or without express.json() middleware
+* app.post("/afs/rpc", expressAdapter(handler));
+* ```
+*/
+function expressAdapter(handler) {
+	return async (req, res, next) => {
+		try {
+			const host = req.get("host") || "localhost";
+			const url = `${req.protocol}://${host}${req.originalUrl}`;
+			let body;
+			if (req.method === "POST" || req.method === "PUT" || req.method === "PATCH") if (req.body !== void 0 && req.body !== null && typeof req.body === "object" && Object.keys(req.body).length > 0) body = JSON.stringify(req.body);
+			else body = await streamToString(req);
+			const response = await handler(new Request(url, {
+				method: req.method,
+				headers: convertHeaders(req.headers),
+				body
+			}));
+			res.status(response.status);
+			response.headers.forEach((value, key) => {
+				res.setHeader(key, value);
+			});
+			const responseBody = await response.text();
+			res.send(responseBody);
+		} catch (error) {
+			next(error instanceof Error ? error : new Error(String(error)));
+		}
+	};
+}
+
+//#endregion
+exports.expressAdapter = expressAdapter;

package/dist/adapters/express.d.cts

@@ -0,0 +1,56 @@
+//#region src/adapters/express.d.ts
+/**
+ * Express-compatible request interface
+ */
+interface ExpressRequest {
+  method: string;
+  protocol: string;
+  originalUrl: string;
+  body?: unknown;
+  headers: Record<string, string | string[] | undefined>;
+  get(name: string): string | undefined;
+  on(event: string, callback: (chunk: Buffer) => void): void;
+  pipe<T extends NodeJS.WritableStream>(destination: T): T;
+}
+/**
+ * Express-compatible response interface
+ */
+interface ExpressResponse {
+  status(code: number): ExpressResponse;
+  setHeader(name: string, value: string): void;
+  send(body: string): void;
+}
+/**
+ * Express-compatible next function
+ */
+type ExpressNextFunction = (error?: Error) => void;
+/**
+ * Express-compatible request handler
+ */
+type ExpressRequestHandler = (req: ExpressRequest, res: ExpressResponse, next: ExpressNextFunction) => void | Promise<void>;
+/**
+ * Express adapter for AFS HTTP handler
+ *
+ * This adapter converts between Express request/response objects and
+ * Web Standard Request/Response objects, handling both scenarios where
+ * body parsing middleware is configured and where it isn't.
+ *
+ * @param handler - The AFS HTTP handler function
+ * @returns An Express-compatible request handler
+ *
+ * @example
+ * ```typescript
+ * import express from "express";
+ * import { createAFSHttpHandler, expressAdapter } from "@aigne/afs-http";
+ *
+ * const handler = createAFSHttpHandler({ module: provider });
+ * const app = express();
+ *
+ * // Works with or without express.json() middleware
+ * app.post("/afs/rpc", expressAdapter(handler));
+ * ```
+ */
+declare function expressAdapter(handler: (request: Request) => Promise<Response>): ExpressRequestHandler;
+//#endregion
+export { expressAdapter };
+//# sourceMappingURL=express.d.cts.map

package/dist/adapters/express.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.d.cts","names":[],"sources":["../../src/adapters/express.ts"],"mappings":";;;;UAKU,cAAA;EAAA,MAAA;EAAA,QAAA;EAAA,WAAA;EAAA,IAAA;EAAA,OAAA,EAKC,MAAA;EAAA,GAAA,CAAA,IAAA;EAAA,EAAA,CAAA,KAAA,UAAA,QAAA,GAAA,KAAA,EAE2B,MAAA;EAAA,IAAA,WACrB,MAAA,CAAO,cAAA,EAAA,WAAA,EAA6B,CAAA,GAAI,CAAA;AAAA;AAAA;;AAAC;AAAD,UAM/C,eAAA;EAAA,MAAA,CAAA,IAAA,WACc,eAAA;EAAA,SAAA,CAAA,IAAA,UAAA,KAAA;EAAA,IAAA,CAAA,IAAA;AAAA;AAAA;AAAe;AAQE;AARjB,KAQnB,mBAAA,IAAA,KAAA,GAA+B,KAAA;AAAA;AAAK;;AAAL,KAK/B,qBAAA,IAAA,GAAA,EACE,cAAA,EAAA,GAAA,EACA,eAAA,EAAA,IAAA,EACC,mBAAA,YACI,OAAA;AAAA;;AAsDZ;;;;;;;;;;;;;;;;;;;;AAtDY,iBAsDI,cAAA,CAAA,OAAA,GAAA,OAAA,EACK,OAAA,KAAY,OAAA,CAAQ,QAAA,IACtC,qBAAA"}

package/dist/adapters/express.d.mts

@@ -0,0 +1,56 @@
+//#region src/adapters/express.d.ts
+/**
+ * Express-compatible request interface
+ */
+interface ExpressRequest {
+  method: string;
+  protocol: string;
+  originalUrl: string;
+  body?: unknown;
+  headers: Record<string, string | string[] | undefined>;
+  get(name: string): string | undefined;
+  on(event: string, callback: (chunk: Buffer) => void): void;
+  pipe<T extends NodeJS.WritableStream>(destination: T): T;
+}
+/**
+ * Express-compatible response interface
+ */
+interface ExpressResponse {
+  status(code: number): ExpressResponse;
+  setHeader(name: string, value: string): void;
+  send(body: string): void;
+}
+/**
+ * Express-compatible next function
+ */
+type ExpressNextFunction = (error?: Error) => void;
+/**
+ * Express-compatible request handler
+ */
+type ExpressRequestHandler = (req: ExpressRequest, res: ExpressResponse, next: ExpressNextFunction) => void | Promise<void>;
+/**
+ * Express adapter for AFS HTTP handler
+ *
+ * This adapter converts between Express request/response objects and
+ * Web Standard Request/Response objects, handling both scenarios where
+ * body parsing middleware is configured and where it isn't.
+ *
+ * @param handler - The AFS HTTP handler function
+ * @returns An Express-compatible request handler
+ *
+ * @example
+ * ```typescript
+ * import express from "express";
+ * import { createAFSHttpHandler, expressAdapter } from "@aigne/afs-http";
+ *
+ * const handler = createAFSHttpHandler({ module: provider });
+ * const app = express();
+ *
+ * // Works with or without express.json() middleware
+ * app.post("/afs/rpc", expressAdapter(handler));
+ * ```
+ */
+declare function expressAdapter(handler: (request: Request) => Promise<Response>): ExpressRequestHandler;
+//#endregion
+export { expressAdapter };
+//# sourceMappingURL=express.d.mts.map

package/dist/adapters/express.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.d.mts","names":[],"sources":["../../src/adapters/express.ts"],"mappings":";;;;UAKU,cAAA;EAAA,MAAA;EAAA,QAAA;EAAA,WAAA;EAAA,IAAA;EAAA,OAAA,EAKC,MAAA;EAAA,GAAA,CAAA,IAAA;EAAA,EAAA,CAAA,KAAA,UAAA,QAAA,GAAA,KAAA,EAE2B,MAAA;EAAA,IAAA,WACrB,MAAA,CAAO,cAAA,EAAA,WAAA,EAA6B,CAAA,GAAI,CAAA;AAAA;AAAA;;AAAC;AAAD,UAM/C,eAAA;EAAA,MAAA,CAAA,IAAA,WACc,eAAA;EAAA,SAAA,CAAA,IAAA,UAAA,KAAA;EAAA,IAAA,CAAA,IAAA;AAAA;AAAA;AAAe;AAQE;AARjB,KAQnB,mBAAA,IAAA,KAAA,GAA+B,KAAA;AAAA;AAAK;;AAAL,KAK/B,qBAAA,IAAA,GAAA,EACE,cAAA,EAAA,GAAA,EACA,eAAA,EAAA,IAAA,EACC,mBAAA,YACI,OAAA;AAAA;;AAsDZ;;;;;;;;;;;;;;;;;;;;AAtDY,iBAsDI,cAAA,CAAA,OAAA,GAAA,OAAA,EACK,OAAA,KAAY,OAAA,CAAQ,QAAA,IACtC,qBAAA"}

package/dist/adapters/express.mjs

@@ -0,0 +1,74 @@
+//#region src/adapters/express.ts
+/**
+* Collect stream data into a string
+*/
+async function streamToString(stream) {
+	const chunks = [];
+	return new Promise((resolve, reject) => {
+		stream.on("data", (chunk) => chunks.push(chunk));
+		stream.on("error", reject);
+		stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+	});
+}
+/**
+* Convert Express headers to Headers object
+*/
+function convertHeaders(headers) {
+	const result = new Headers();
+	for (const [key, value] of Object.entries(headers)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) for (const v of value) result.append(key, v);
+		else result.set(key, value);
+	}
+	return result;
+}
+/**
+* Express adapter for AFS HTTP handler
+*
+* This adapter converts between Express request/response objects and
+* Web Standard Request/Response objects, handling both scenarios where
+* body parsing middleware is configured and where it isn't.
+*
+* @param handler - The AFS HTTP handler function
+* @returns An Express-compatible request handler
+*
+* @example
+* ```typescript
+* import express from "express";
+* import { createAFSHttpHandler, expressAdapter } from "@aigne/afs-http";
+*
+* const handler = createAFSHttpHandler({ module: provider });
+* const app = express();
+*
+* // Works with or without express.json() middleware
+* app.post("/afs/rpc", expressAdapter(handler));
+* ```
+*/
+function expressAdapter(handler) {
+	return async (req, res, next) => {
+		try {
+			const host = req.get("host") || "localhost";
+			const url = `${req.protocol}://${host}${req.originalUrl}`;
+			let body;
+			if (req.method === "POST" || req.method === "PUT" || req.method === "PATCH") if (req.body !== void 0 && req.body !== null && typeof req.body === "object" && Object.keys(req.body).length > 0) body = JSON.stringify(req.body);
+			else body = await streamToString(req);
+			const response = await handler(new Request(url, {
+				method: req.method,
+				headers: convertHeaders(req.headers),
+				body
+			}));
+			res.status(response.status);
+			response.headers.forEach((value, key) => {
+				res.setHeader(key, value);
+			});
+			const responseBody = await response.text();
+			res.send(responseBody);
+		} catch (error) {
+			next(error instanceof Error ? error : new Error(String(error)));
+		}
+	};
+}
+
+//#endregion
+export { expressAdapter };
+//# sourceMappingURL=express.mjs.map

package/dist/adapters/express.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"express.mjs","names":[],"sources":["../../src/adapters/express.ts"],"sourcesContent":["import type { Readable } from \"node:stream\";\n\n/**\n * Express-compatible request interface\n */\ninterface ExpressRequest {\n  method: string;\n  protocol: string;\n  originalUrl: string;\n  body?: unknown;\n  headers: Record<string, string | string[] | undefined>;\n  get(name: string): string | undefined;\n  on(event: string, callback: (chunk: Buffer) => void): void;\n  pipe<T extends NodeJS.WritableStream>(destination: T): T;\n}\n\n/**\n * Express-compatible response interface\n */\ninterface ExpressResponse {\n  status(code: number): ExpressResponse;\n  setHeader(name: string, value: string): void;\n  send(body: string): void;\n}\n\n/**\n * Express-compatible next function\n */\ntype ExpressNextFunction = (error?: Error) => void;\n\n/**\n * Express-compatible request handler\n */\ntype ExpressRequestHandler = (\n  req: ExpressRequest,\n  res: ExpressResponse,\n  next: ExpressNextFunction,\n) => void | Promise<void>;\n\n/**\n * Collect stream data into a string\n */\nasync function streamToString(stream: Readable): Promise<string> {\n  const chunks: Buffer[] = [];\n  return new Promise((resolve, reject) => {\n    stream.on(\"data\", (chunk: Buffer) => chunks.push(chunk));\n    stream.on(\"error\", reject);\n    stream.on(\"end\", () => resolve(Buffer.concat(chunks).toString(\"utf8\")));\n  });\n}\n\n/**\n * Convert Express headers to Headers object\n */\nfunction convertHeaders(headers: Record<string, string | string[] | undefined>): Headers {\n  const result = new Headers();\n  for (const [key, value] of Object.entries(headers)) {\n    if (value === undefined) continue;\n    if (Array.isArray(value)) {\n      for (const v of value) {\n        result.append(key, v);\n      }\n    } else {\n      result.set(key, value);\n    }\n  }\n  return result;\n}\n\n/**\n * Express adapter for AFS HTTP handler\n *\n * This adapter converts between Express request/response objects and\n * Web Standard Request/Response objects, handling both scenarios where\n * body parsing middleware is configured and where it isn't.\n *\n * @param handler - The AFS HTTP handler function\n * @returns An Express-compatible request handler\n *\n * @example\n * ```typescript\n * import express from \"express\";\n * import { createAFSHttpHandler, expressAdapter } from \"@aigne/afs-http\";\n *\n * const handler = createAFSHttpHandler({ module: provider });\n * const app = express();\n *\n * // Works with or without express.json() middleware\n * app.post(\"/afs/rpc\", expressAdapter(handler));\n * ```\n */\nexport function expressAdapter(\n  handler: (request: Request) => Promise<Response>,\n): ExpressRequestHandler {\n  return async (req, res, next) => {\n    try {\n      // Build URL from request\n      const host = req.get(\"host\") || \"localhost\";\n      const url = `${req.protocol}://${host}${req.originalUrl}`;\n\n      // Get body - handle both parsed and unparsed scenarios\n      let body: string | undefined;\n\n      if (req.method === \"POST\" || req.method === \"PUT\" || req.method === \"PATCH\") {\n        if (\n          req.body !== undefined &&\n          req.body !== null &&\n          typeof req.body === \"object\" &&\n          Object.keys(req.body).length > 0\n        ) {\n          // Scenario 1: Body already parsed by middleware (e.g., express.json())\n          body = JSON.stringify(req.body);\n        } else {\n          // Scenario 2: Body not parsed, read from stream\n          body = await streamToString(req as unknown as Readable);\n        }\n      }\n\n      // Create Web Standard Request\n      const request = new Request(url, {\n        method: req.method,\n        headers: convertHeaders(req.headers),\n        body,\n      });\n\n      // Call the handler\n      const response = await handler(request);\n\n      // Write response back to Express\n      res.status(response.status);\n\n      // Copy headers\n      response.headers.forEach((value, key) => {\n        res.setHeader(key, value);\n      });\n\n      // Send body\n      const responseBody = await response.text();\n      res.send(responseBody);\n    } catch (error) {\n      next(error instanceof Error ? error : new Error(String(error)));\n    }\n  };\n}\n"],"mappings":";;;;AA0CA,eAAe,eAAe,QAAmC;CAC/D,MAAM,SAAmB,EAAE;AAC3B,QAAO,IAAI,SAAS,SAAS,WAAW;AACtC,SAAO,GAAG,SAAS,UAAkB,OAAO,KAAK,MAAM,CAAC;AACxD,SAAO,GAAG,SAAS,OAAO;AAC1B,SAAO,GAAG,aAAa,QAAQ,OAAO,OAAO,OAAO,CAAC,SAAS,OAAO,CAAC,CAAC;GACvE;;;;;AAMJ,SAAS,eAAe,SAAiE;CACvF,MAAM,SAAS,IAAI,SAAS;AAC5B,MAAK,MAAM,CAAC,KAAK,UAAU,OAAO,QAAQ,QAAQ,EAAE;AAClD,MAAI,UAAU,OAAW;AACzB,MAAI,MAAM,QAAQ,MAAM,CACtB,MAAK,MAAM,KAAK,MACd,QAAO,OAAO,KAAK,EAAE;MAGvB,QAAO,IAAI,KAAK,MAAM;;AAG1B,QAAO;;;;;;;;;;;;;;;;;;;;;;;;AAyBT,SAAgB,eACd,SACuB;AACvB,QAAO,OAAO,KAAK,KAAK,SAAS;AAC/B,MAAI;GAEF,MAAM,OAAO,IAAI,IAAI,OAAO,IAAI;GAChC,MAAM,MAAM,GAAG,IAAI,SAAS,KAAK,OAAO,IAAI;GAG5C,IAAI;AAEJ,OAAI,IAAI,WAAW,UAAU,IAAI,WAAW,SAAS,IAAI,WAAW,QAClE,KACE,IAAI,SAAS,UACb,IAAI,SAAS,QACb,OAAO,IAAI,SAAS,YACpB,OAAO,KAAK,IAAI,KAAK,CAAC,SAAS,EAG/B,QAAO,KAAK,UAAU,IAAI,KAAK;OAG/B,QAAO,MAAM,eAAe,IAA2B;GAY3D,MAAM,WAAW,MAAM,QAPP,IAAI,QAAQ,KAAK;IAC/B,QAAQ,IAAI;IACZ,SAAS,eAAe,IAAI,QAAQ;IACpC;IACD,CAAC,CAGqC;AAGvC,OAAI,OAAO,SAAS,OAAO;AAG3B,YAAS,QAAQ,SAAS,OAAO,QAAQ;AACvC,QAAI,UAAU,KAAK,MAAM;KACzB;GAGF,MAAM,eAAe,MAAM,SAAS,MAAM;AAC1C,OAAI,KAAK,aAAa;WACf,OAAO;AACd,QAAK,iBAAiB,QAAQ,QAAQ,IAAI,MAAM,OAAO,MAAM,CAAC,CAAC"}

package/dist/adapters/koa.cjs

@@ -0,0 +1,73 @@
+
+//#region src/adapters/koa.ts
+/**
+* Collect stream data into a string
+*/
+async function streamToString(stream) {
+	const chunks = [];
+	return new Promise((resolve, reject) => {
+		stream.on("data", (chunk) => chunks.push(chunk));
+		stream.on("error", reject);
+		stream.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+	});
+}
+/**
+* Convert Koa headers to Headers object
+*/
+function convertHeaders(headers) {
+	const result = new Headers();
+	for (const [key, value] of Object.entries(headers)) {
+		if (value === void 0) continue;
+		if (Array.isArray(value)) for (const v of value) result.append(key, v);
+		else result.set(key, value);
+	}
+	return result;
+}
+/**
+* Koa adapter for AFS HTTP handler
+*
+* This adapter converts between Koa context and Web Standard Request/Response
+* objects, handling both scenarios where body parsing middleware is configured
+* (like koa-bodyparser) and where it isn't.
+*
+* @param handler - The AFS HTTP handler function
+* @returns A Koa-compatible middleware
+*
+* @example
+* ```typescript
+* import Koa from "koa";
+* import Router from "@koa/router";
+* import { createAFSHttpHandler, koaAdapter } from "@aigne/afs-http";
+*
+* const handler = createAFSHttpHandler({ module: provider });
+* const app = new Koa();
+* const router = new Router();
+*
+* router.post("/afs/rpc", koaAdapter(handler));
+* app.use(router.routes());
+* ```
+*/
+function koaAdapter(handler) {
+	return async (ctx, _next) => {
+		const url = `${ctx.protocol}://${ctx.host}${ctx.originalUrl}`;
+		let body;
+		if (ctx.method === "POST" || ctx.method === "PUT" || ctx.method === "PATCH") {
+			const requestBody = ctx.request.body;
+			if (requestBody !== void 0 && requestBody !== null && typeof requestBody === "object" && Object.keys(requestBody).length > 0) body = JSON.stringify(requestBody);
+			else body = await streamToString(ctx.req);
+		}
+		const response = await handler(new Request(url, {
+			method: ctx.method,
+			headers: convertHeaders(ctx.request.headers),
+			body
+		}));
+		ctx.status = response.status;
+		response.headers.forEach((value, key) => {
+			ctx.set(key, value);
+		});
+		ctx.body = await response.text();
+	};
+}
+
+//#endregion
+exports.koaAdapter = koaAdapter;