@aigne/afs-http 1.11.0-beta.3

package/dist/errors.cjs

@@ -0,0 +1,105 @@
+const require_protocol = require('./protocol.cjs');
+
+//#region src/errors.ts
+/**
+* Base class for AFS HTTP errors
+*/
+var AFSHttpError = class extends Error {
+	constructor(message, code, httpStatus = 200, details) {
+		super(message);
+		this.code = code;
+		this.httpStatus = httpStatus;
+		this.details = details;
+		this.name = "AFSHttpError";
+	}
+};
+/**
+* Path not found error
+*/
+var AFSNotFoundError = class extends AFSHttpError {
+	constructor(path, details) {
+		super(`Path not found: ${path}`, require_protocol.AFSErrorCode.NOT_FOUND, 200, details);
+		this.name = "AFSNotFoundError";
+	}
+};
+/**
+* Permission denied error (including readonly mode)
+*/
+var AFSPermissionError = class extends AFSHttpError {
+	constructor(message, details) {
+		super(message, require_protocol.AFSErrorCode.PERMISSION_DENIED, 200, details);
+		this.name = "AFSPermissionError";
+	}
+};
+/**
+* Conflict error (concurrent modification)
+*/
+var AFSConflictError = class extends AFSHttpError {
+	constructor(message, details) {
+		super(message, require_protocol.AFSErrorCode.CONFLICT, 200, details);
+		this.name = "AFSConflictError";
+	}
+};
+/**
+* Runtime error
+*/
+var AFSRuntimeError = class extends AFSHttpError {
+	constructor(message, details) {
+		super(message, require_protocol.AFSErrorCode.RUNTIME_ERROR, 200, details);
+		this.name = "AFSRuntimeError";
+	}
+};
+/**
+* Invalid request error (bad JSON, invalid method, etc.)
+*/
+var AFSInvalidRequestError = class extends AFSHttpError {
+	constructor(message, details) {
+		super(message, require_protocol.AFSErrorCode.RUNTIME_ERROR, 400, details);
+		this.name = "AFSInvalidRequestError";
+	}
+};
+/**
+* Payload too large error
+*/
+var AFSPayloadTooLargeError = class extends AFSHttpError {
+	constructor(maxSize, actualSize) {
+		const message = actualSize ? `Payload too large: ${actualSize} bytes exceeds limit of ${maxSize} bytes` : `Payload too large: exceeds limit of ${maxSize} bytes`;
+		super(message, require_protocol.AFSErrorCode.RUNTIME_ERROR, 413, {
+			maxSize,
+			actualSize
+		});
+		this.name = "AFSPayloadTooLargeError";
+	}
+};
+/**
+* Network error (for client-side use)
+*/
+var AFSNetworkError = class extends Error {
+	constructor(message, cause, retryable = true) {
+		super(message);
+		this.cause = cause;
+		this.retryable = retryable;
+		this.name = "AFSNetworkError";
+	}
+};
+/**
+* Map common error messages to appropriate AFS error codes
+*/
+function mapErrorToCode(error) {
+	const message = error.message.toLowerCase();
+	if (message.includes("not found") || message.includes("enoent") || message.includes("does not exist")) return require_protocol.AFSErrorCode.NOT_FOUND;
+	if (message.includes("permission") || message.includes("readonly") || message.includes("read-only") || message.includes("access denied") || message.includes("eacces")) return require_protocol.AFSErrorCode.PERMISSION_DENIED;
+	if (message.includes("conflict") || message.includes("already exists") || message.includes("eexist")) return require_protocol.AFSErrorCode.CONFLICT;
+	return require_protocol.AFSErrorCode.RUNTIME_ERROR;
+}
+
+//#endregion
+exports.AFSConflictError = AFSConflictError;
+exports.AFSHttpError = AFSHttpError;
+exports.AFSInvalidRequestError = AFSInvalidRequestError;
+exports.AFSNetworkError = AFSNetworkError;
+exports.AFSNotFoundError = AFSNotFoundError;
+exports.AFSPayloadTooLargeError = AFSPayloadTooLargeError;
+exports.AFSPermissionError = AFSPermissionError;
+exports.AFSRuntimeError = AFSRuntimeError;
+exports.mapErrorToCode = mapErrorToCode;

package/dist/errors.d.cts

@@ -0,0 +1,63 @@
+import { AFSErrorCode } from "./protocol.cjs";
+
+//#region src/errors.d.ts
+/**
+ * Base class for AFS HTTP errors
+ */
+declare class AFSHttpError extends Error {
+  readonly code: AFSErrorCode;
+  readonly httpStatus: number;
+  readonly details?: unknown | undefined;
+  constructor(message: string, code: AFSErrorCode, httpStatus?: number, details?: unknown | undefined);
+}
+/**
+ * Path not found error
+ */
+declare class AFSNotFoundError extends AFSHttpError {
+  constructor(path: string, details?: unknown);
+}
+/**
+ * Permission denied error (including readonly mode)
+ */
+declare class AFSPermissionError extends AFSHttpError {
+  constructor(message: string, details?: unknown);
+}
+/**
+ * Conflict error (concurrent modification)
+ */
+declare class AFSConflictError extends AFSHttpError {
+  constructor(message: string, details?: unknown);
+}
+/**
+ * Runtime error
+ */
+declare class AFSRuntimeError extends AFSHttpError {
+  constructor(message: string, details?: unknown);
+}
+/**
+ * Invalid request error (bad JSON, invalid method, etc.)
+ */
+declare class AFSInvalidRequestError extends AFSHttpError {
+  constructor(message: string, details?: unknown);
+}
+/**
+ * Payload too large error
+ */
+declare class AFSPayloadTooLargeError extends AFSHttpError {
+  constructor(maxSize: number, actualSize?: number);
+}
+/**
+ * Network error (for client-side use)
+ */
+declare class AFSNetworkError extends Error {
+  readonly cause?: Error | undefined;
+  readonly retryable: boolean;
+  constructor(message: string, cause?: Error | undefined, retryable?: boolean);
+}
+/**
+ * Map common error messages to appropriate AFS error codes
+ */
+declare function mapErrorToCode(error: Error): AFSErrorCode;
+//#endregion
+export { AFSConflictError, AFSHttpError, AFSInvalidRequestError, AFSNetworkError, AFSNotFoundError, AFSPayloadTooLargeError, AFSPermissionError, AFSRuntimeError, mapErrorToCode };
+//# sourceMappingURL=errors.d.cts.map

package/dist/errors.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.cts","names":[],"sources":["../src/errors.ts"],"mappings":";;;;AAKA;;cAAa,YAAA,SAAqB,KAAA;EAAA,SAAA,IAAA,EAGR,YAAA;EAAA,SAAA,UAAA;EAAA,SAAA,OAAA;EAAA,YAAA,OAAA,UAAA,IAAA,EAAA,YAAA,EAAA,UAAA,WAAA,OAAA;AAAA;AAAA;;;AAAA,cAYb,gBAAA,SAAyB,YAAA;EAAA,YAAA,IAAA,UAAA,OAAA;AAAA;AAAA;AAUtC;AAUA;AApBsC,cAUzB,kBAAA,SAA2B,YAAA;EAAA,YAAA,OAAA,UAAA,OAAA;AAAA;AAAA;AAUxC;AAUA;AApBwC,cAU3B,gBAAA,SAAyB,YAAA;EAAA,YAAA,OAAA,UAAA,OAAA;AAAA;AAAA;AAUtC;AAUA;AApBsC,cAUzB,eAAA,SAAwB,YAAA;EAAA,YAAA,OAAA,UAAA,OAAA;AAAA;AAAA;AAUrC;AAUA;AApBqC,cAUxB,sBAAA,SAA+B,YAAA;EAAA,YAAA,OAAA,UAAA,OAAA;AAAA;AAAA;AAU5C;AAaA;AAvB4C,cAU/B,uBAAA,SAAgC,YAAA;EAAA,YAAA,OAAA,UAAA,UAAA;AAAA;AAAA;AAa7C;;AAb6C,cAahC,eAAA,SAAwB,KAAA;EAAA,SAAA,KAAA,GAGT,KAAA;EAAA,SAAA,SAAA;EAAA,YAAA,OAAA,UAAA,KAAA,GAAA,KAAA,cAAA,SAAA;AAAA;AAAA;;;AAAA,iBAWZ,cAAA,CAAA,KAAA,EAAsB,KAAA,GAAQ,YAAA"}

package/dist/errors.d.mts

@@ -0,0 +1,63 @@
+import { AFSErrorCode } from "./protocol.mjs";
+
+//#region src/errors.d.ts
+/**
+ * Base class for AFS HTTP errors
+ */
+declare class AFSHttpError extends Error {
+  readonly code: AFSErrorCode;
+  readonly httpStatus: number;
+  readonly details?: unknown | undefined;
+  constructor(message: string, code: AFSErrorCode, httpStatus?: number, details?: unknown | undefined);
+}
+/**
+ * Path not found error
+ */
+declare class AFSNotFoundError extends AFSHttpError {
+  constructor(path: string, details?: unknown);
+}
+/**
+ * Permission denied error (including readonly mode)
+ */
+declare class AFSPermissionError extends AFSHttpError {
+  constructor(message: string, details?: unknown);
+}
+/**
+ * Conflict error (concurrent modification)
+ */
+declare class AFSConflictError extends AFSHttpError {
+  constructor(message: string, details?: unknown);
+}
+/**
+ * Runtime error
+ */
+declare class AFSRuntimeError extends AFSHttpError {
+  constructor(message: string, details?: unknown);
+}
+/**
+ * Invalid request error (bad JSON, invalid method, etc.)
+ */
+declare class AFSInvalidRequestError extends AFSHttpError {
+  constructor(message: string, details?: unknown);
+}
+/**
+ * Payload too large error
+ */
+declare class AFSPayloadTooLargeError extends AFSHttpError {
+  constructor(maxSize: number, actualSize?: number);
+}
+/**
+ * Network error (for client-side use)
+ */
+declare class AFSNetworkError extends Error {
+  readonly cause?: Error | undefined;
+  readonly retryable: boolean;
+  constructor(message: string, cause?: Error | undefined, retryable?: boolean);
+}
+/**
+ * Map common error messages to appropriate AFS error codes
+ */
+declare function mapErrorToCode(error: Error): AFSErrorCode;
+//#endregion
+export { AFSConflictError, AFSHttpError, AFSInvalidRequestError, AFSNetworkError, AFSNotFoundError, AFSPayloadTooLargeError, AFSPermissionError, AFSRuntimeError, mapErrorToCode };
+//# sourceMappingURL=errors.d.mts.map

package/dist/errors.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.mts","names":[],"sources":["../src/errors.ts"],"mappings":";;;;AAKA;;cAAa,YAAA,SAAqB,KAAA;EAAA,SAAA,IAAA,EAGR,YAAA;EAAA,SAAA,UAAA;EAAA,SAAA,OAAA;EAAA,YAAA,OAAA,UAAA,IAAA,EAAA,YAAA,EAAA,UAAA,WAAA,OAAA;AAAA;AAAA;;;AAAA,cAYb,gBAAA,SAAyB,YAAA;EAAA,YAAA,IAAA,UAAA,OAAA;AAAA;AAAA;AAUtC;AAUA;AApBsC,cAUzB,kBAAA,SAA2B,YAAA;EAAA,YAAA,OAAA,UAAA,OAAA;AAAA;AAAA;AAUxC;AAUA;AApBwC,cAU3B,gBAAA,SAAyB,YAAA;EAAA,YAAA,OAAA,UAAA,OAAA;AAAA;AAAA;AAUtC;AAUA;AApBsC,cAUzB,eAAA,SAAwB,YAAA;EAAA,YAAA,OAAA,UAAA,OAAA;AAAA;AAAA;AAUrC;AAUA;AApBqC,cAUxB,sBAAA,SAA+B,YAAA;EAAA,YAAA,OAAA,UAAA,OAAA;AAAA;AAAA;AAU5C;AAaA;AAvB4C,cAU/B,uBAAA,SAAgC,YAAA;EAAA,YAAA,OAAA,UAAA,UAAA;AAAA;AAAA;AAa7C;;AAb6C,cAahC,eAAA,SAAwB,KAAA;EAAA,SAAA,KAAA,GAGT,KAAA;EAAA,SAAA,SAAA;EAAA,YAAA,OAAA,UAAA,KAAA,GAAA,KAAA,cAAA,SAAA;AAAA;AAAA;;;AAAA,iBAWZ,cAAA,CAAA,KAAA,EAAsB,KAAA,GAAQ,YAAA"}

package/dist/errors.mjs

@@ -0,0 +1,98 @@
+import { AFSErrorCode } from "./protocol.mjs";
+
+//#region src/errors.ts
+/**
+* Base class for AFS HTTP errors
+*/
+var AFSHttpError = class extends Error {
+	constructor(message, code, httpStatus = 200, details) {
+		super(message);
+		this.code = code;
+		this.httpStatus = httpStatus;
+		this.details = details;
+		this.name = "AFSHttpError";
+	}
+};
+/**
+* Path not found error
+*/
+var AFSNotFoundError = class extends AFSHttpError {
+	constructor(path, details) {
+		super(`Path not found: ${path}`, AFSErrorCode.NOT_FOUND, 200, details);
+		this.name = "AFSNotFoundError";
+	}
+};
+/**
+* Permission denied error (including readonly mode)
+*/
+var AFSPermissionError = class extends AFSHttpError {
+	constructor(message, details) {
+		super(message, AFSErrorCode.PERMISSION_DENIED, 200, details);
+		this.name = "AFSPermissionError";
+	}
+};
+/**
+* Conflict error (concurrent modification)
+*/
+var AFSConflictError = class extends AFSHttpError {
+	constructor(message, details) {
+		super(message, AFSErrorCode.CONFLICT, 200, details);
+		this.name = "AFSConflictError";
+	}
+};
+/**
+* Runtime error
+*/
+var AFSRuntimeError = class extends AFSHttpError {
+	constructor(message, details) {
+		super(message, AFSErrorCode.RUNTIME_ERROR, 200, details);
+		this.name = "AFSRuntimeError";
+	}
+};
+/**
+* Invalid request error (bad JSON, invalid method, etc.)
+*/
+var AFSInvalidRequestError = class extends AFSHttpError {
+	constructor(message, details) {
+		super(message, AFSErrorCode.RUNTIME_ERROR, 400, details);
+		this.name = "AFSInvalidRequestError";
+	}
+};
+/**
+* Payload too large error
+*/
+var AFSPayloadTooLargeError = class extends AFSHttpError {
+	constructor(maxSize, actualSize) {
+		const message = actualSize ? `Payload too large: ${actualSize} bytes exceeds limit of ${maxSize} bytes` : `Payload too large: exceeds limit of ${maxSize} bytes`;
+		super(message, AFSErrorCode.RUNTIME_ERROR, 413, {
+			maxSize,
+			actualSize
+		});
+		this.name = "AFSPayloadTooLargeError";
+	}
+};
+/**
+* Network error (for client-side use)
+*/
+var AFSNetworkError = class extends Error {
+	constructor(message, cause, retryable = true) {
+		super(message);
+		this.cause = cause;
+		this.retryable = retryable;
+		this.name = "AFSNetworkError";
+	}
+};
+/**
+* Map common error messages to appropriate AFS error codes
+*/
+function mapErrorToCode(error) {
+	const message = error.message.toLowerCase();
+	if (message.includes("not found") || message.includes("enoent") || message.includes("does not exist")) return AFSErrorCode.NOT_FOUND;
+	if (message.includes("permission") || message.includes("readonly") || message.includes("read-only") || message.includes("access denied") || message.includes("eacces")) return AFSErrorCode.PERMISSION_DENIED;
+	if (message.includes("conflict") || message.includes("already exists") || message.includes("eexist")) return AFSErrorCode.CONFLICT;
+	return AFSErrorCode.RUNTIME_ERROR;
+}
+
+//#endregion
+export { AFSConflictError, AFSHttpError, AFSInvalidRequestError, AFSNetworkError, AFSNotFoundError, AFSPayloadTooLargeError, AFSPermissionError, AFSRuntimeError, mapErrorToCode };
+//# sourceMappingURL=errors.mjs.map

package/dist/errors.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.mjs","names":[],"sources":["../src/errors.ts"],"sourcesContent":["import { AFSErrorCode } from \"./protocol.js\";\n\n/**\n * Base class for AFS HTTP errors\n */\nexport class AFSHttpError extends Error {\n  constructor(\n    message: string,\n    public readonly code: AFSErrorCode,\n    public readonly httpStatus: number = 200,\n    public readonly details?: unknown,\n  ) {\n    super(message);\n    this.name = \"AFSHttpError\";\n  }\n}\n\n/**\n * Path not found error\n */\nexport class AFSNotFoundError extends AFSHttpError {\n  constructor(path: string, details?: unknown) {\n    super(`Path not found: ${path}`, AFSErrorCode.NOT_FOUND, 200, details);\n    this.name = \"AFSNotFoundError\";\n  }\n}\n\n/**\n * Permission denied error (including readonly mode)\n */\nexport class AFSPermissionError extends AFSHttpError {\n  constructor(message: string, details?: unknown) {\n    super(message, AFSErrorCode.PERMISSION_DENIED, 200, details);\n    this.name = \"AFSPermissionError\";\n  }\n}\n\n/**\n * Conflict error (concurrent modification)\n */\nexport class AFSConflictError extends AFSHttpError {\n  constructor(message: string, details?: unknown) {\n    super(message, AFSErrorCode.CONFLICT, 200, details);\n    this.name = \"AFSConflictError\";\n  }\n}\n\n/**\n * Runtime error\n */\nexport class AFSRuntimeError extends AFSHttpError {\n  constructor(message: string, details?: unknown) {\n    super(message, AFSErrorCode.RUNTIME_ERROR, 200, details);\n    this.name = \"AFSRuntimeError\";\n  }\n}\n\n/**\n * Invalid request error (bad JSON, invalid method, etc.)\n */\nexport class AFSInvalidRequestError extends AFSHttpError {\n  constructor(message: string, details?: unknown) {\n    super(message, AFSErrorCode.RUNTIME_ERROR, 400, details);\n    this.name = \"AFSInvalidRequestError\";\n  }\n}\n\n/**\n * Payload too large error\n */\nexport class AFSPayloadTooLargeError extends AFSHttpError {\n  constructor(maxSize: number, actualSize?: number) {\n    const message = actualSize\n      ? `Payload too large: ${actualSize} bytes exceeds limit of ${maxSize} bytes`\n      : `Payload too large: exceeds limit of ${maxSize} bytes`;\n    super(message, AFSErrorCode.RUNTIME_ERROR, 413, { maxSize, actualSize });\n    this.name = \"AFSPayloadTooLargeError\";\n  }\n}\n\n/**\n * Network error (for client-side use)\n */\nexport class AFSNetworkError extends Error {\n  constructor(\n    message: string,\n    public readonly cause?: Error,\n    public readonly retryable: boolean = true,\n  ) {\n    super(message);\n    this.name = \"AFSNetworkError\";\n  }\n}\n\n/**\n * Map common error messages to appropriate AFS error codes\n */\nexport function mapErrorToCode(error: Error): AFSErrorCode {\n  const message = error.message.toLowerCase();\n\n  if (\n    message.includes(\"not found\") ||\n    message.includes(\"enoent\") ||\n    message.includes(\"does not exist\")\n  ) {\n    return AFSErrorCode.NOT_FOUND;\n  }\n\n  if (\n    message.includes(\"permission\") ||\n    message.includes(\"readonly\") ||\n    message.includes(\"read-only\") ||\n    message.includes(\"access denied\") ||\n    message.includes(\"eacces\")\n  ) {\n    return AFSErrorCode.PERMISSION_DENIED;\n  }\n\n  if (\n    message.includes(\"conflict\") ||\n    message.includes(\"already exists\") ||\n    message.includes(\"eexist\")\n  ) {\n    return AFSErrorCode.CONFLICT;\n  }\n\n  return AFSErrorCode.RUNTIME_ERROR;\n}\n"],"mappings":";;;;;;AAKA,IAAa,eAAb,cAAkC,MAAM;CACtC,YACE,SACA,AAAgB,MAChB,AAAgB,aAAqB,KACrC,AAAgB,SAChB;AACA,QAAM,QAAQ;EAJE;EACA;EACA;AAGhB,OAAK,OAAO;;;;;;AAOhB,IAAa,mBAAb,cAAsC,aAAa;CACjD,YAAY,MAAc,SAAmB;AAC3C,QAAM,mBAAmB,QAAQ,aAAa,WAAW,KAAK,QAAQ;AACtE,OAAK,OAAO;;;;;;AAOhB,IAAa,qBAAb,cAAwC,aAAa;CACnD,YAAY,SAAiB,SAAmB;AAC9C,QAAM,SAAS,aAAa,mBAAmB,KAAK,QAAQ;AAC5D,OAAK,OAAO;;;;;;AAOhB,IAAa,mBAAb,cAAsC,aAAa;CACjD,YAAY,SAAiB,SAAmB;AAC9C,QAAM,SAAS,aAAa,UAAU,KAAK,QAAQ;AACnD,OAAK,OAAO;;;;;;AAOhB,IAAa,kBAAb,cAAqC,aAAa;CAChD,YAAY,SAAiB,SAAmB;AAC9C,QAAM,SAAS,aAAa,eAAe,KAAK,QAAQ;AACxD,OAAK,OAAO;;;;;;AAOhB,IAAa,yBAAb,cAA4C,aAAa;CACvD,YAAY,SAAiB,SAAmB;AAC9C,QAAM,SAAS,aAAa,eAAe,KAAK,QAAQ;AACxD,OAAK,OAAO;;;;;;AAOhB,IAAa,0BAAb,cAA6C,aAAa;CACxD,YAAY,SAAiB,YAAqB;EAChD,MAAM,UAAU,aACZ,sBAAsB,WAAW,0BAA0B,QAAQ,UACnE,uCAAuC,QAAQ;AACnD,QAAM,SAAS,aAAa,eAAe,KAAK;GAAE;GAAS;GAAY,CAAC;AACxE,OAAK,OAAO;;;;;;AAOhB,IAAa,kBAAb,cAAqC,MAAM;CACzC,YACE,SACA,AAAgB,OAChB,AAAgB,YAAqB,MACrC;AACA,QAAM,QAAQ;EAHE;EACA;AAGhB,OAAK,OAAO;;;;;;AAOhB,SAAgB,eAAe,OAA4B;CACzD,MAAM,UAAU,MAAM,QAAQ,aAAa;AAE3C,KACE,QAAQ,SAAS,YAAY,IAC7B,QAAQ,SAAS,SAAS,IAC1B,QAAQ,SAAS,iBAAiB,CAElC,QAAO,aAAa;AAGtB,KACE,QAAQ,SAAS,aAAa,IAC9B,QAAQ,SAAS,WAAW,IAC5B,QAAQ,SAAS,YAAY,IAC7B,QAAQ,SAAS,gBAAgB,IACjC,QAAQ,SAAS,SAAS,CAE1B,QAAO,aAAa;AAGtB,KACE,QAAQ,SAAS,WAAW,IAC5B,QAAQ,SAAS,iBAAiB,IAClC,QAAQ,SAAS,SAAS,CAE1B,QAAO,aAAa;AAGtB,QAAO,aAAa"}

package/dist/handler.cjs

@@ -0,0 +1,126 @@
+const require_protocol = require('./protocol.cjs');
+const require_errors = require('./errors.cjs');
+
+//#region src/handler.ts
+/**
+* Default handler options
+*/
+const DEFAULT_OPTIONS = {
+	maxBodySize: 10 * 1024 * 1024,
+	timeout: 3e4
+};
+/**
+* Create an AFS HTTP handler function
+*
+* This function creates a pure handler that accepts a Web Standard Request
+* and returns a Web Standard Response. It can be used with any HTTP framework
+* that supports these standards (Hono, Bun, Deno, etc.) or adapted for
+* frameworks like Express and Koa.
+*
+* @param options - Handler options
+* @returns A handler function that processes AFS RPC requests
+*
+* @example
+* ```typescript
+* // With Hono
+* const handler = createAFSHttpHandler({ module: provider });
+* app.post("/afs/rpc", (c) => handler(c.req.raw));
+*
+* // With Bun
+* Bun.serve({
+*   fetch(req) {
+*     if (url.pathname === "/afs/rpc") return handler(req);
+*   }
+* });
+* ```
+*/
+function createAFSHttpHandler(options) {
+	const { module, maxBodySize = DEFAULT_OPTIONS.maxBodySize } = options;
+	return async (request) => {
+		try {
+			if (request.method !== "POST") return createJsonResponse(require_protocol.createErrorResponse(require_protocol.AFSErrorCode.RUNTIME_ERROR, `Method not allowed: ${request.method}`), 405);
+			if (!request.headers.get("content-type")?.includes("application/json")) return createJsonResponse(require_protocol.createErrorResponse(require_protocol.AFSErrorCode.RUNTIME_ERROR, "Content-Type must be application/json"), 400);
+			const contentLength = request.headers.get("content-length");
+			if (contentLength && Number.parseInt(contentLength, 10) > maxBodySize) {
+				const error = new require_errors.AFSPayloadTooLargeError(maxBodySize, Number.parseInt(contentLength, 10));
+				return createJsonResponse(require_protocol.createErrorResponse(error.code, error.message, error.details), error.httpStatus);
+			}
+			let body;
+			try {
+				const text = await request.text();
+				if (text.length > maxBodySize) {
+					const error = new require_errors.AFSPayloadTooLargeError(maxBodySize, text.length);
+					return createJsonResponse(require_protocol.createErrorResponse(error.code, error.message, error.details), error.httpStatus);
+				}
+				body = JSON.parse(text);
+			} catch {
+				return createJsonResponse(require_protocol.createErrorResponse(require_protocol.AFSErrorCode.RUNTIME_ERROR, "Invalid JSON body"), 400);
+			}
+			if (!body || typeof body !== "object") return createJsonResponse(require_protocol.createErrorResponse(require_protocol.AFSErrorCode.RUNTIME_ERROR, "Request body must be an object"), 400);
+			const { method, params } = body;
+			if (!method || typeof method !== "string") return createJsonResponse(require_protocol.createErrorResponse(require_protocol.AFSErrorCode.RUNTIME_ERROR, "Missing or invalid method"), 400);
+			if (!require_protocol.isValidRpcMethod(method)) return createJsonResponse(require_protocol.createErrorResponse(require_protocol.AFSErrorCode.RUNTIME_ERROR, `Unknown method: ${method}`), 400);
+			if (!params || typeof params !== "object") return createJsonResponse(require_protocol.createErrorResponse(require_protocol.AFSErrorCode.RUNTIME_ERROR, "Missing or invalid params"), 400);
+			return createJsonResponse(require_protocol.createSuccessResponse(await executeRpcMethod(module, method, params)), 200);
+		} catch (error) {
+			if (error instanceof require_errors.AFSHttpError) return createJsonResponse(require_protocol.createErrorResponse(error.code, error.message, error.details), error.httpStatus);
+			const message = error instanceof Error ? error.message : String(error);
+			return createJsonResponse(require_protocol.createErrorResponse(error instanceof Error ? require_errors.mapErrorToCode(error) : require_protocol.AFSErrorCode.RUNTIME_ERROR, message), 200);
+		}
+	};
+}
+/**
+* Execute an RPC method on the module
+*/
+async function executeRpcMethod(module, method, params) {
+	switch (method) {
+		case "list": {
+			if (!module.list) throw new require_errors.AFSInvalidRequestError("Module does not support list operation");
+			const { path, options } = params;
+			return await module.list(path, options);
+		}
+		case "read": {
+			if (!module.read) throw new require_errors.AFSInvalidRequestError("Module does not support read operation");
+			const { path, options } = params;
+			return await module.read(path, options);
+		}
+		case "write": {
+			if (!module.write) throw new require_errors.AFSInvalidRequestError("Module does not support write operation");
+			const { path, content, options } = params;
+			return await module.write(path, content, options);
+		}
+		case "delete": {
+			if (!module.delete) throw new require_errors.AFSInvalidRequestError("Module does not support delete operation");
+			const { path, options } = params;
+			return await module.delete(path, options);
+		}
+		case "rename": {
+			if (!module.rename) throw new require_errors.AFSInvalidRequestError("Module does not support rename operation");
+			const { oldPath, newPath, options } = params;
+			return await module.rename(oldPath, newPath, options);
+		}
+		case "search": {
+			if (!module.search) throw new require_errors.AFSInvalidRequestError("Module does not support search operation");
+			const { path, query, options } = params;
+			return await module.search(path, query, options);
+		}
+		case "exec": {
+			if (!module.exec) throw new require_errors.AFSInvalidRequestError("Module does not support exec operation");
+			const { path, args, options } = params;
+			return await module.exec(path, args, options);
+		}
+		default: throw new require_errors.AFSInvalidRequestError(`Unknown method: ${method}`);
+	}
+}
+/**
+* Create a JSON Response with proper headers
+*/
+function createJsonResponse(body, status) {
+	return new Response(JSON.stringify(body), {
+		status,
+		headers: { "Content-Type": "application/json" }
+	});
+}
+
+//#endregion
+exports.createAFSHttpHandler = createAFSHttpHandler;

package/dist/handler.d.cts

@@ -0,0 +1,43 @@
+import { AFSModule } from "@aigne/afs";
+
+//#region src/handler.d.ts
+/**
+ * Options for creating an AFS HTTP handler
+ */
+interface AFSHttpHandlerOptions {
+  /** The AFS module to expose */
+  module: AFSModule;
+  /** Maximum request body size in bytes (default: 10MB) */
+  maxBodySize?: number;
+  /** Request timeout in milliseconds (default: 30000) */
+  timeout?: number;
+}
+/**
+ * Create an AFS HTTP handler function
+ *
+ * This function creates a pure handler that accepts a Web Standard Request
+ * and returns a Web Standard Response. It can be used with any HTTP framework
+ * that supports these standards (Hono, Bun, Deno, etc.) or adapted for
+ * frameworks like Express and Koa.
+ *
+ * @param options - Handler options
+ * @returns A handler function that processes AFS RPC requests
+ *
+ * @example
+ * ```typescript
+ * // With Hono
+ * const handler = createAFSHttpHandler({ module: provider });
+ * app.post("/afs/rpc", (c) => handler(c.req.raw));
+ *
+ * // With Bun
+ * Bun.serve({
+ *   fetch(req) {
+ *     if (url.pathname === "/afs/rpc") return handler(req);
+ *   }
+ * });
+ * ```
+ */
+declare function createAFSHttpHandler(options: AFSHttpHandlerOptions): (request: Request) => Promise<Response>;
+//#endregion
+export { AFSHttpHandlerOptions, createAFSHttpHandler };
+//# sourceMappingURL=handler.d.cts.map

package/dist/handler.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.cts","names":[],"sources":["../src/handler.ts"],"mappings":";;;;AAoBA;AA0CA;UA1CiB,qBAAA;EAAA;EAAA,MAAA,EAEP,SAAA;EAAA;EAAA,WAAA;EAAA;EAAA,OAAA;AAAA;AAAA;AAwCV;;;;;;;;;;;;;;;;;;;;;;;;AAxCU,iBAwCM,oBAAA,CAAA,OAAA,EACL,qBAAA,IAAA,OAAA,EACE,OAAA,KAAY,OAAA,CAAQ,QAAA"}

package/dist/handler.d.mts

@@ -0,0 +1,43 @@
+import { AFSModule } from "@aigne/afs";
+
+//#region src/handler.d.ts
+/**
+ * Options for creating an AFS HTTP handler
+ */
+interface AFSHttpHandlerOptions {
+  /** The AFS module to expose */
+  module: AFSModule;
+  /** Maximum request body size in bytes (default: 10MB) */
+  maxBodySize?: number;
+  /** Request timeout in milliseconds (default: 30000) */
+  timeout?: number;
+}
+/**
+ * Create an AFS HTTP handler function
+ *
+ * This function creates a pure handler that accepts a Web Standard Request
+ * and returns a Web Standard Response. It can be used with any HTTP framework
+ * that supports these standards (Hono, Bun, Deno, etc.) or adapted for
+ * frameworks like Express and Koa.
+ *
+ * @param options - Handler options
+ * @returns A handler function that processes AFS RPC requests
+ *
+ * @example
+ * ```typescript
+ * // With Hono
+ * const handler = createAFSHttpHandler({ module: provider });
+ * app.post("/afs/rpc", (c) => handler(c.req.raw));
+ *
+ * // With Bun
+ * Bun.serve({
+ *   fetch(req) {
+ *     if (url.pathname === "/afs/rpc") return handler(req);
+ *   }
+ * });
+ * ```
+ */
+declare function createAFSHttpHandler(options: AFSHttpHandlerOptions): (request: Request) => Promise<Response>;
+//#endregion
+export { AFSHttpHandlerOptions, createAFSHttpHandler };
+//# sourceMappingURL=handler.d.mts.map

package/dist/handler.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.d.mts","names":[],"sources":["../src/handler.ts"],"mappings":";;;;AAoBA;AA0CA;UA1CiB,qBAAA;EAAA;EAAA,MAAA,EAEP,SAAA;EAAA;EAAA,WAAA;EAAA;EAAA,OAAA;AAAA;AAAA;AAwCV;;;;;;;;;;;;;;;;;;;;;;;;AAxCU,iBAwCM,oBAAA,CAAA,OAAA,EACL,qBAAA,IAAA,OAAA,EACE,OAAA,KAAY,OAAA,CAAQ,QAAA"}