@aigne/afs-http 1.11.0-beta.3

package/dist/handler.mjs

@@ -0,0 +1,127 @@
+import { AFSErrorCode, createErrorResponse, createSuccessResponse, isValidRpcMethod } from "./protocol.mjs";
+import { AFSHttpError, AFSInvalidRequestError, AFSPayloadTooLargeError, mapErrorToCode } from "./errors.mjs";
+
+//#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(createErrorResponse(AFSErrorCode.RUNTIME_ERROR, `Method not allowed: ${request.method}`), 405);
+			if (!request.headers.get("content-type")?.includes("application/json")) return createJsonResponse(createErrorResponse(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 AFSPayloadTooLargeError(maxBodySize, Number.parseInt(contentLength, 10));
+				return createJsonResponse(createErrorResponse(error.code, error.message, error.details), error.httpStatus);
+			}
+			let body;
+			try {
+				const text = await request.text();
+				if (text.length > maxBodySize) {
+					const error = new AFSPayloadTooLargeError(maxBodySize, text.length);
+					return createJsonResponse(createErrorResponse(error.code, error.message, error.details), error.httpStatus);
+				}
+				body = JSON.parse(text);
+			} catch {
+				return createJsonResponse(createErrorResponse(AFSErrorCode.RUNTIME_ERROR, "Invalid JSON body"), 400);
+			}
+			if (!body || typeof body !== "object") return createJsonResponse(createErrorResponse(AFSErrorCode.RUNTIME_ERROR, "Request body must be an object"), 400);
+			const { method, params } = body;
+			if (!method || typeof method !== "string") return createJsonResponse(createErrorResponse(AFSErrorCode.RUNTIME_ERROR, "Missing or invalid method"), 400);
+			if (!isValidRpcMethod(method)) return createJsonResponse(createErrorResponse(AFSErrorCode.RUNTIME_ERROR, `Unknown method: ${method}`), 400);
+			if (!params || typeof params !== "object") return createJsonResponse(createErrorResponse(AFSErrorCode.RUNTIME_ERROR, "Missing or invalid params"), 400);
+			return createJsonResponse(createSuccessResponse(await executeRpcMethod(module, method, params)), 200);
+		} catch (error) {
+			if (error instanceof AFSHttpError) return createJsonResponse(createErrorResponse(error.code, error.message, error.details), error.httpStatus);
+			const message = error instanceof Error ? error.message : String(error);
+			return createJsonResponse(createErrorResponse(error instanceof Error ? mapErrorToCode(error) : 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 AFSInvalidRequestError("Module does not support list operation");
+			const { path, options } = params;
+			return await module.list(path, options);
+		}
+		case "read": {
+			if (!module.read) throw new AFSInvalidRequestError("Module does not support read operation");
+			const { path, options } = params;
+			return await module.read(path, options);
+		}
+		case "write": {
+			if (!module.write) throw new 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 AFSInvalidRequestError("Module does not support delete operation");
+			const { path, options } = params;
+			return await module.delete(path, options);
+		}
+		case "rename": {
+			if (!module.rename) throw new 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 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 AFSInvalidRequestError("Module does not support exec operation");
+			const { path, args, options } = params;
+			return await module.exec(path, args, options);
+		}
+		default: throw new 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
+export { createAFSHttpHandler };
+//# sourceMappingURL=handler.mjs.map

package/dist/handler.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"handler.mjs","names":[],"sources":["../src/handler.ts"],"sourcesContent":["import type { AFSModule } from \"@aigne/afs\";\nimport {\n  AFSHttpError,\n  AFSInvalidRequestError,\n  AFSPayloadTooLargeError,\n  mapErrorToCode,\n} from \"./errors.js\";\nimport {\n  AFSErrorCode,\n  type AFSRpcMethod,\n  type AFSRpcRequest,\n  type AFSRpcResponse,\n  createErrorResponse,\n  createSuccessResponse,\n  isValidRpcMethod,\n} from \"./protocol.js\";\n\n/**\n * Options for creating an AFS HTTP handler\n */\nexport interface AFSHttpHandlerOptions {\n  /** The AFS module to expose */\n  module: AFSModule;\n  /** Maximum request body size in bytes (default: 10MB) */\n  maxBodySize?: number;\n  /** Request timeout in milliseconds (default: 30000) */\n  timeout?: number;\n}\n\n/**\n * Default handler options\n */\nconst DEFAULT_OPTIONS = {\n  maxBodySize: 10 * 1024 * 1024, // 10MB\n  timeout: 30000, // 30 seconds\n};\n\n/**\n * Create an AFS HTTP handler function\n *\n * This function creates a pure handler that accepts a Web Standard Request\n * and returns a Web Standard Response. It can be used with any HTTP framework\n * that supports these standards (Hono, Bun, Deno, etc.) or adapted for\n * frameworks like Express and Koa.\n *\n * @param options - Handler options\n * @returns A handler function that processes AFS RPC requests\n *\n * @example\n * ```typescript\n * // With Hono\n * const handler = createAFSHttpHandler({ module: provider });\n * app.post(\"/afs/rpc\", (c) => handler(c.req.raw));\n *\n * // With Bun\n * Bun.serve({\n *   fetch(req) {\n *     if (url.pathname === \"/afs/rpc\") return handler(req);\n *   }\n * });\n * ```\n */\nexport function createAFSHttpHandler(\n  options: AFSHttpHandlerOptions,\n): (request: Request) => Promise<Response> {\n  const { module, maxBodySize = DEFAULT_OPTIONS.maxBodySize } = options;\n\n  return async (request: Request): Promise<Response> => {\n    try {\n      // Validate HTTP method\n      if (request.method !== \"POST\") {\n        return createJsonResponse(\n          createErrorResponse(AFSErrorCode.RUNTIME_ERROR, `Method not allowed: ${request.method}`),\n          405,\n        );\n      }\n\n      // Check Content-Type\n      const contentType = request.headers.get(\"content-type\");\n      if (!contentType?.includes(\"application/json\")) {\n        return createJsonResponse(\n          createErrorResponse(AFSErrorCode.RUNTIME_ERROR, \"Content-Type must be application/json\"),\n          400,\n        );\n      }\n\n      // Check Content-Length if available\n      const contentLength = request.headers.get(\"content-length\");\n      if (contentLength && Number.parseInt(contentLength, 10) > maxBodySize) {\n        const error = new AFSPayloadTooLargeError(maxBodySize, Number.parseInt(contentLength, 10));\n        return createJsonResponse(\n          createErrorResponse(error.code, error.message, error.details),\n          error.httpStatus,\n        );\n      }\n\n      // Parse request body\n      let body: AFSRpcRequest;\n      try {\n        const text = await request.text();\n        if (text.length > maxBodySize) {\n          const error = new AFSPayloadTooLargeError(maxBodySize, text.length);\n          return createJsonResponse(\n            createErrorResponse(error.code, error.message, error.details),\n            error.httpStatus,\n          );\n        }\n        body = JSON.parse(text);\n      } catch {\n        return createJsonResponse(\n          createErrorResponse(AFSErrorCode.RUNTIME_ERROR, \"Invalid JSON body\"),\n          400,\n        );\n      }\n\n      // Validate request structure\n      if (!body || typeof body !== \"object\") {\n        return createJsonResponse(\n          createErrorResponse(AFSErrorCode.RUNTIME_ERROR, \"Request body must be an object\"),\n          400,\n        );\n      }\n\n      const { method, params } = body;\n\n      // Validate method\n      if (!method || typeof method !== \"string\") {\n        return createJsonResponse(\n          createErrorResponse(AFSErrorCode.RUNTIME_ERROR, \"Missing or invalid method\"),\n          400,\n        );\n      }\n\n      if (!isValidRpcMethod(method)) {\n        return createJsonResponse(\n          createErrorResponse(AFSErrorCode.RUNTIME_ERROR, `Unknown method: ${method}`),\n          400,\n        );\n      }\n\n      // Validate params\n      if (!params || typeof params !== \"object\") {\n        return createJsonResponse(\n          createErrorResponse(AFSErrorCode.RUNTIME_ERROR, \"Missing or invalid params\"),\n          400,\n        );\n      }\n\n      // Execute the RPC method\n      const result = await executeRpcMethod(module, method, params);\n      return createJsonResponse(createSuccessResponse(result), 200);\n    } catch (error) {\n      // Handle known AFS errors\n      if (error instanceof AFSHttpError) {\n        return createJsonResponse(\n          createErrorResponse(error.code, error.message, error.details),\n          error.httpStatus,\n        );\n      }\n\n      // Handle unknown errors\n      const message = error instanceof Error ? error.message : String(error);\n      const code = error instanceof Error ? mapErrorToCode(error) : AFSErrorCode.RUNTIME_ERROR;\n      return createJsonResponse(createErrorResponse(code, message), 200);\n    }\n  };\n}\n\n/**\n * Execute an RPC method on the module\n */\nasync function executeRpcMethod(\n  module: AFSModule,\n  method: AFSRpcMethod,\n  params: Record<string, unknown>,\n): Promise<unknown> {\n  switch (method) {\n    case \"list\": {\n      if (!module.list) {\n        throw new AFSInvalidRequestError(\"Module does not support list operation\");\n      }\n      const { path, options } = params as { path: string; options?: unknown };\n      return await module.list(path, options as any);\n    }\n\n    case \"read\": {\n      if (!module.read) {\n        throw new AFSInvalidRequestError(\"Module does not support read operation\");\n      }\n      const { path, options } = params as { path: string; options?: unknown };\n      return await module.read(path, options as any);\n    }\n\n    case \"write\": {\n      if (!module.write) {\n        throw new AFSInvalidRequestError(\"Module does not support write operation\");\n      }\n      const { path, content, options } = params as {\n        path: string;\n        content: unknown;\n        options?: unknown;\n      };\n      return await module.write(path, content as any, options as any);\n    }\n\n    case \"delete\": {\n      if (!module.delete) {\n        throw new AFSInvalidRequestError(\"Module does not support delete operation\");\n      }\n      const { path, options } = params as { path: string; options?: unknown };\n      return await module.delete(path, options as any);\n    }\n\n    case \"rename\": {\n      if (!module.rename) {\n        throw new AFSInvalidRequestError(\"Module does not support rename operation\");\n      }\n      const { oldPath, newPath, options } = params as {\n        oldPath: string;\n        newPath: string;\n        options?: unknown;\n      };\n      return await module.rename(oldPath, newPath, options as any);\n    }\n\n    case \"search\": {\n      if (!module.search) {\n        throw new AFSInvalidRequestError(\"Module does not support search operation\");\n      }\n      const { path, query, options } = params as {\n        path: string;\n        query: string;\n        options?: unknown;\n      };\n      return await module.search(path, query, options as any);\n    }\n\n    case \"exec\": {\n      if (!module.exec) {\n        throw new AFSInvalidRequestError(\"Module does not support exec operation\");\n      }\n      const { path, args, options } = params as {\n        path: string;\n        args: Record<string, unknown>;\n        options?: unknown;\n      };\n      return await module.exec(path, args, options as any);\n    }\n\n    default: {\n      // TypeScript exhaustiveness check\n      const _exhaustive: never = method;\n      throw new AFSInvalidRequestError(`Unknown method: ${_exhaustive}`);\n    }\n  }\n}\n\n/**\n * Create a JSON Response with proper headers\n */\nfunction createJsonResponse(body: AFSRpcResponse, status: number): Response {\n  return new Response(JSON.stringify(body), {\n    status,\n    headers: {\n      \"Content-Type\": \"application/json\",\n    },\n  });\n}\n"],"mappings":"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"}

package/dist/index.cjs

@@ -0,0 +1,33 @@
+const require_express = require('./adapters/express.cjs');
+const require_koa = require('./adapters/koa.cjs');
+const require_protocol = require('./protocol.cjs');
+const require_errors = require('./errors.cjs');
+const require_retry = require('./retry.cjs');
+const require_client = require('./client.cjs');
+const require_handler = require('./handler.cjs');
+
+exports.AFSConflictError = require_errors.AFSConflictError;
+exports.AFSErrorCode = require_protocol.AFSErrorCode;
+exports.AFSHttpClient = require_client.AFSHttpClient;
+exports.AFSHttpError = require_errors.AFSHttpError;
+exports.AFSInvalidRequestError = require_errors.AFSInvalidRequestError;
+exports.AFSNetworkError = require_errors.AFSNetworkError;
+exports.AFSNotFoundError = require_errors.AFSNotFoundError;
+exports.AFSPayloadTooLargeError = require_errors.AFSPayloadTooLargeError;
+exports.AFSPermissionError = require_errors.AFSPermissionError;
+exports.AFSRuntimeError = require_errors.AFSRuntimeError;
+exports.DEFAULT_RETRY_OPTIONS = require_retry.DEFAULT_RETRY_OPTIONS;
+exports.VALID_RPC_METHODS = require_protocol.VALID_RPC_METHODS;
+exports.calculateDelay = require_retry.calculateDelay;
+exports.createAFSHttpHandler = require_handler.createAFSHttpHandler;
+exports.createErrorResponse = require_protocol.createErrorResponse;
+exports.createSuccessResponse = require_protocol.createSuccessResponse;
+exports.expressAdapter = require_express.expressAdapter;
+exports.fetchWithRetry = require_retry.fetchWithRetry;
+exports.isRetryableError = require_retry.isRetryableError;
+exports.isRetryableStatus = require_retry.isRetryableStatus;
+exports.isValidRpcMethod = require_protocol.isValidRpcMethod;
+exports.koaAdapter = require_koa.koaAdapter;
+exports.mapErrorToCode = require_errors.mapErrorToCode;
+exports.sleep = require_retry.sleep;
+exports.withRetry = require_retry.withRetry;

package/dist/index.d.cts

@@ -0,0 +1,8 @@
+import { expressAdapter } from "./adapters/express.cjs";
+import { koaAdapter } from "./adapters/koa.cjs";
+import { DEFAULT_RETRY_OPTIONS, RetryOptions, calculateDelay, fetchWithRetry, isRetryableError, isRetryableStatus, sleep, withRetry } from "./retry.cjs";
+import { AFSHttpClient, AFSHttpClientOptions } from "./client.cjs";
+import { AFSErrorCode, AFSRpcError, AFSRpcMethod, AFSRpcParams, AFSRpcRequest, AFSRpcResponse, AFSRpcResults, VALID_RPC_METHODS, createErrorResponse, createSuccessResponse, isValidRpcMethod } from "./protocol.cjs";
+import { AFSConflictError, AFSHttpError, AFSInvalidRequestError, AFSNetworkError, AFSNotFoundError, AFSPayloadTooLargeError, AFSPermissionError, AFSRuntimeError, mapErrorToCode } from "./errors.cjs";
+import { AFSHttpHandlerOptions, createAFSHttpHandler } from "./handler.cjs";
+export { AFSConflictError, AFSErrorCode, AFSHttpClient, type AFSHttpClientOptions, AFSHttpError, type AFSHttpHandlerOptions, AFSInvalidRequestError, AFSNetworkError, AFSNotFoundError, AFSPayloadTooLargeError, AFSPermissionError, type AFSRpcError, type AFSRpcMethod, type AFSRpcParams, type AFSRpcRequest, type AFSRpcResponse, type AFSRpcResults, AFSRuntimeError, DEFAULT_RETRY_OPTIONS, type RetryOptions, VALID_RPC_METHODS, calculateDelay, createAFSHttpHandler, createErrorResponse, createSuccessResponse, expressAdapter, fetchWithRetry, isRetryableError, isRetryableStatus, isValidRpcMethod, koaAdapter, mapErrorToCode, sleep, withRetry };

package/dist/index.d.mts

@@ -0,0 +1,8 @@
+import { expressAdapter } from "./adapters/express.mjs";
+import { koaAdapter } from "./adapters/koa.mjs";
+import { DEFAULT_RETRY_OPTIONS, RetryOptions, calculateDelay, fetchWithRetry, isRetryableError, isRetryableStatus, sleep, withRetry } from "./retry.mjs";
+import { AFSHttpClient, AFSHttpClientOptions } from "./client.mjs";
+import { AFSErrorCode, AFSRpcError, AFSRpcMethod, AFSRpcParams, AFSRpcRequest, AFSRpcResponse, AFSRpcResults, VALID_RPC_METHODS, createErrorResponse, createSuccessResponse, isValidRpcMethod } from "./protocol.mjs";
+import { AFSConflictError, AFSHttpError, AFSInvalidRequestError, AFSNetworkError, AFSNotFoundError, AFSPayloadTooLargeError, AFSPermissionError, AFSRuntimeError, mapErrorToCode } from "./errors.mjs";
+import { AFSHttpHandlerOptions, createAFSHttpHandler } from "./handler.mjs";
+export { AFSConflictError, AFSErrorCode, AFSHttpClient, type AFSHttpClientOptions, AFSHttpError, type AFSHttpHandlerOptions, AFSInvalidRequestError, AFSNetworkError, AFSNotFoundError, AFSPayloadTooLargeError, AFSPermissionError, type AFSRpcError, type AFSRpcMethod, type AFSRpcParams, type AFSRpcRequest, type AFSRpcResponse, type AFSRpcResults, AFSRuntimeError, DEFAULT_RETRY_OPTIONS, type RetryOptions, VALID_RPC_METHODS, calculateDelay, createAFSHttpHandler, createErrorResponse, createSuccessResponse, expressAdapter, fetchWithRetry, isRetryableError, isRetryableStatus, isValidRpcMethod, koaAdapter, mapErrorToCode, sleep, withRetry };

package/dist/index.mjs

@@ -0,0 +1,9 @@
+import { expressAdapter } from "./adapters/express.mjs";
+import { koaAdapter } from "./adapters/koa.mjs";
+import { AFSErrorCode, VALID_RPC_METHODS, createErrorResponse, createSuccessResponse, isValidRpcMethod } from "./protocol.mjs";
+import { AFSConflictError, AFSHttpError, AFSInvalidRequestError, AFSNetworkError, AFSNotFoundError, AFSPayloadTooLargeError, AFSPermissionError, AFSRuntimeError, mapErrorToCode } from "./errors.mjs";
+import { DEFAULT_RETRY_OPTIONS, calculateDelay, fetchWithRetry, isRetryableError, isRetryableStatus, sleep, withRetry } from "./retry.mjs";
+import { AFSHttpClient } from "./client.mjs";
+import { createAFSHttpHandler } from "./handler.mjs";
+
+export { AFSConflictError, AFSErrorCode, AFSHttpClient, AFSHttpError, AFSInvalidRequestError, AFSNetworkError, AFSNotFoundError, AFSPayloadTooLargeError, AFSPermissionError, AFSRuntimeError, DEFAULT_RETRY_OPTIONS, VALID_RPC_METHODS, calculateDelay, createAFSHttpHandler, createErrorResponse, createSuccessResponse, expressAdapter, fetchWithRetry, isRetryableError, isRetryableStatus, isValidRpcMethod, koaAdapter, mapErrorToCode, sleep, withRetry };

package/dist/protocol.cjs

@@ -0,0 +1,68 @@
+
+//#region src/protocol.ts
+/**
+* CLI-compatible error codes
+* @see https://github.com/arcblock/afs/blob/main/intent/specs/afs-cli-spec.md
+*/
+let AFSErrorCode = /* @__PURE__ */ function(AFSErrorCode) {
+	/** Operation successful */
+	AFSErrorCode[AFSErrorCode["OK"] = 0] = "OK";
+	/** Path not found */
+	AFSErrorCode[AFSErrorCode["NOT_FOUND"] = 1] = "NOT_FOUND";
+	/** Permission denied (including readonly mode) */
+	AFSErrorCode[AFSErrorCode["PERMISSION_DENIED"] = 2] = "PERMISSION_DENIED";
+	/** Concurrent modification conflict */
+	AFSErrorCode[AFSErrorCode["CONFLICT"] = 3] = "CONFLICT";
+	/** Partial success */
+	AFSErrorCode[AFSErrorCode["PARTIAL"] = 4] = "PARTIAL";
+	/** Runtime error */
+	AFSErrorCode[AFSErrorCode["RUNTIME_ERROR"] = 5] = "RUNTIME_ERROR";
+	return AFSErrorCode;
+}({});
+/**
+* Valid RPC methods set for validation
+*/
+const VALID_RPC_METHODS = new Set([
+	"list",
+	"read",
+	"write",
+	"delete",
+	"rename",
+	"search",
+	"exec"
+]);
+/**
+* Check if a string is a valid RPC method
+*/
+function isValidRpcMethod(method) {
+	return VALID_RPC_METHODS.has(method);
+}
+/**
+* Create a success response
+*/
+function createSuccessResponse(data) {
+	return {
+		success: true,
+		data
+	};
+}
+/**
+* Create an error response
+*/
+function createErrorResponse(code, message, details) {
+	return {
+		success: false,
+		error: {
+			code,
+			message,
+			details
+		}
+	};
+}
+
+//#endregion
+exports.AFSErrorCode = AFSErrorCode;
+exports.VALID_RPC_METHODS = VALID_RPC_METHODS;
+exports.createErrorResponse = createErrorResponse;
+exports.createSuccessResponse = createSuccessResponse;
+exports.isValidRpcMethod = isValidRpcMethod;

package/dist/protocol.d.cts

@@ -0,0 +1,119 @@
+import { AFSDeleteOptions, AFSDeleteResult, AFSExecOptions, AFSExecResult, AFSListOptions, AFSListResult, AFSReadOptions, AFSReadResult, AFSRenameOptions, AFSRenameResult, AFSSearchOptions, AFSSearchResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+
+//#region src/protocol.d.ts
+/**
+ * AFS HTTP RPC method names
+ */
+type AFSRpcMethod = "list" | "read" | "write" | "delete" | "rename" | "search" | "exec";
+/**
+ * RPC request body
+ */
+interface AFSRpcRequest<M extends AFSRpcMethod = AFSRpcMethod> {
+  method: M;
+  params: AFSRpcParams[M];
+}
+/**
+ * RPC response body
+ */
+interface AFSRpcResponse<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: AFSRpcError;
+}
+/**
+ * RPC error object
+ */
+interface AFSRpcError {
+  /** CLI error code (0-5), compatible with AFS CLI */
+  code: AFSErrorCode;
+  /** Human-readable error message */
+  message: string;
+  /** Additional error details */
+  details?: unknown;
+}
+/**
+ * CLI-compatible error codes
+ * @see https://github.com/arcblock/afs/blob/main/intent/specs/afs-cli-spec.md
+ */
+declare enum AFSErrorCode {
+  /** Operation successful */
+  OK = 0,
+  /** Path not found */
+  NOT_FOUND = 1,
+  /** Permission denied (including readonly mode) */
+  PERMISSION_DENIED = 2,
+  /** Concurrent modification conflict */
+  CONFLICT = 3,
+  /** Partial success */
+  PARTIAL = 4,
+  /** Runtime error */
+  RUNTIME_ERROR = 5,
+}
+/**
+ * Parameter types for each RPC method
+ */
+interface AFSRpcParams {
+  list: {
+    path: string;
+    options?: AFSListOptions;
+  };
+  read: {
+    path: string;
+    options?: AFSReadOptions;
+  };
+  write: {
+    path: string;
+    content: AFSWriteEntryPayload;
+    options?: AFSWriteOptions;
+  };
+  delete: {
+    path: string;
+    options?: AFSDeleteOptions;
+  };
+  rename: {
+    oldPath: string;
+    newPath: string;
+    options?: AFSRenameOptions;
+  };
+  search: {
+    path: string;
+    query: string;
+    options?: AFSSearchOptions;
+  };
+  exec: {
+    path: string;
+    args: Record<string, unknown>;
+    options?: AFSExecOptions;
+  };
+}
+/**
+ * Result types for each RPC method
+ */
+interface AFSRpcResults {
+  list: AFSListResult;
+  read: AFSReadResult;
+  write: AFSWriteResult;
+  delete: AFSDeleteResult;
+  rename: AFSRenameResult;
+  search: AFSSearchResult;
+  exec: AFSExecResult;
+}
+/**
+ * Valid RPC methods set for validation
+ */
+declare const VALID_RPC_METHODS: Set<AFSRpcMethod>;
+/**
+ * Check if a string is a valid RPC method
+ */
+declare function isValidRpcMethod(method: string): method is AFSRpcMethod;
+/**
+ * Create a success response
+ */
+declare function createSuccessResponse<T>(data: T): AFSRpcResponse<T>;
+/**
+ * Create an error response
+ */
+declare function createErrorResponse(code: AFSErrorCode, message: string, details?: unknown): AFSRpcResponse<never>;
+//#endregion
+export { AFSErrorCode, AFSRpcError, AFSRpcMethod, AFSRpcParams, AFSRpcRequest, AFSRpcResponse, AFSRpcResults, VALID_RPC_METHODS, createErrorResponse, createSuccessResponse, isValidRpcMethod };
+//# sourceMappingURL=protocol.d.cts.map

package/dist/protocol.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.cts","names":[],"sources":["../src/protocol.ts"],"mappings":";;;;AAqBA;AAKA;KALY,YAAA;AAAA;AAKZ;;AALY,UAKK,aAAA,WAAwB,YAAA,GAAe,YAAA;EAAA,MAAA,EAC9C,CAAA;EAAA,MAAA,EACA,YAAA,CAAa,CAAA;AAAA;AAAA;;AAMvB;AANuB,UAMN,cAAA;EAAA,OAAA;EAAA,IAAA,GAER,CAAA;EAAA,KAAA,GACC,WAAA;AAAA;AAAA;AAMV;AAaA;AAnBU,UAMO,WAAA;EAAA;EAAA,IAAA,EAET,YAAA;EAAA;EAAA,OAAA;EAAA;EAAA,OAAA;AAAA;AAAA;AAWR;AAkBA;;AA7BQ,aAWI,YAAA;EAAA;EAAA,EAAA;EAAA;EAAA,SAAA;EAAA;EAAA,iBAAA;EAAA;EAAA,QAAA;EAAA;EAAA,OAAA;EAAA;EAAA,aAAA;AAAA;AAAA;AAkBZ;;AAlBY,UAkBK,YAAA;EAAA,IAAA;IAAA,IAAA;IAAA,OAAA,GAGH,cAAA;EAAA;EAAA,IAAA;IAAA,IAAA;IAAA,OAAA,GAIA,cAAA;EAAA;EAAA,KAAA;IAAA,IAAA;IAAA,OAAA,EAID,oBAAA;IAAA,OAAA,GACC,eAAA;EAAA;EAAA,MAAA;IAAA,IAAA;IAAA,OAAA,GAIA,gBAAA;EAAA;EAAA,MAAA;IAAA,OAAA;IAAA,OAAA;IAAA,OAAA,GAKA,gBAAA;EAAA;EAAA,MAAA;IAAA,IAAA;IAAA,KAAA;IAAA,OAAA,GAKA,gBAAA;EAAA;EAAA,IAAA;IAAA,IAAA;IAAA,IAAA,EAIJ,MAAA;IAAA,OAAA,GACI,cAAA;EAAA;AAAA;AAAA;;AAOd;AAPc,UAOG,aAAA;EAAA,IAAA,EACT,aAAA;EAAA,IAAA,EACA,aAAA;EAAA,KAAA,EACC,cAAA;EAAA,MAAA,EACC,eAAA;EAAA,MAAA,EACA,eAAA;EAAA,MAAA,EACA,eAAA;EAAA,IAAA,EACF,aAAA;AAAA;AAAA;;AAMR;AANQ,cAMK,iBAAA,EAAmB,GAAA,CAAI,YAAA;AAAA;AAapC;AAOA;AApBoC,iBAapB,gBAAA,CAAA,MAAA,WAAA,MAAA,IAA4C,YAAA;AAAA;AAO5D;;AAP4D,iBAO5C,qBAAA,GAAA,CAAA,IAAA,EAA+B,CAAA,GAAI,cAAA,CAAe,CAAA;AAAA;;;AAAA,iBAUlD,mBAAA,CAAA,IAAA,EACR,YAAA,EAAA,OAAA,UAAA,OAAA,aAGL,cAAA"}

package/dist/protocol.d.mts

@@ -0,0 +1,119 @@
+import { AFSDeleteOptions, AFSDeleteResult, AFSExecOptions, AFSExecResult, AFSListOptions, AFSListResult, AFSReadOptions, AFSReadResult, AFSRenameOptions, AFSRenameResult, AFSSearchOptions, AFSSearchResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+
+//#region src/protocol.d.ts
+/**
+ * AFS HTTP RPC method names
+ */
+type AFSRpcMethod = "list" | "read" | "write" | "delete" | "rename" | "search" | "exec";
+/**
+ * RPC request body
+ */
+interface AFSRpcRequest<M extends AFSRpcMethod = AFSRpcMethod> {
+  method: M;
+  params: AFSRpcParams[M];
+}
+/**
+ * RPC response body
+ */
+interface AFSRpcResponse<T = unknown> {
+  success: boolean;
+  data?: T;
+  error?: AFSRpcError;
+}
+/**
+ * RPC error object
+ */
+interface AFSRpcError {
+  /** CLI error code (0-5), compatible with AFS CLI */
+  code: AFSErrorCode;
+  /** Human-readable error message */
+  message: string;
+  /** Additional error details */
+  details?: unknown;
+}
+/**
+ * CLI-compatible error codes
+ * @see https://github.com/arcblock/afs/blob/main/intent/specs/afs-cli-spec.md
+ */
+declare enum AFSErrorCode {
+  /** Operation successful */
+  OK = 0,
+  /** Path not found */
+  NOT_FOUND = 1,
+  /** Permission denied (including readonly mode) */
+  PERMISSION_DENIED = 2,
+  /** Concurrent modification conflict */
+  CONFLICT = 3,
+  /** Partial success */
+  PARTIAL = 4,
+  /** Runtime error */
+  RUNTIME_ERROR = 5,
+}
+/**
+ * Parameter types for each RPC method
+ */
+interface AFSRpcParams {
+  list: {
+    path: string;
+    options?: AFSListOptions;
+  };
+  read: {
+    path: string;
+    options?: AFSReadOptions;
+  };
+  write: {
+    path: string;
+    content: AFSWriteEntryPayload;
+    options?: AFSWriteOptions;
+  };
+  delete: {
+    path: string;
+    options?: AFSDeleteOptions;
+  };
+  rename: {
+    oldPath: string;
+    newPath: string;
+    options?: AFSRenameOptions;
+  };
+  search: {
+    path: string;
+    query: string;
+    options?: AFSSearchOptions;
+  };
+  exec: {
+    path: string;
+    args: Record<string, unknown>;
+    options?: AFSExecOptions;
+  };
+}
+/**
+ * Result types for each RPC method
+ */
+interface AFSRpcResults {
+  list: AFSListResult;
+  read: AFSReadResult;
+  write: AFSWriteResult;
+  delete: AFSDeleteResult;
+  rename: AFSRenameResult;
+  search: AFSSearchResult;
+  exec: AFSExecResult;
+}
+/**
+ * Valid RPC methods set for validation
+ */
+declare const VALID_RPC_METHODS: Set<AFSRpcMethod>;
+/**
+ * Check if a string is a valid RPC method
+ */
+declare function isValidRpcMethod(method: string): method is AFSRpcMethod;
+/**
+ * Create a success response
+ */
+declare function createSuccessResponse<T>(data: T): AFSRpcResponse<T>;
+/**
+ * Create an error response
+ */
+declare function createErrorResponse(code: AFSErrorCode, message: string, details?: unknown): AFSRpcResponse<never>;
+//#endregion
+export { AFSErrorCode, AFSRpcError, AFSRpcMethod, AFSRpcParams, AFSRpcRequest, AFSRpcResponse, AFSRpcResults, VALID_RPC_METHODS, createErrorResponse, createSuccessResponse, isValidRpcMethod };
+//# sourceMappingURL=protocol.d.mts.map

package/dist/protocol.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.mts","names":[],"sources":["../src/protocol.ts"],"mappings":";;;;AAqBA;AAKA;KALY,YAAA;AAAA;AAKZ;;AALY,UAKK,aAAA,WAAwB,YAAA,GAAe,YAAA;EAAA,MAAA,EAC9C,CAAA;EAAA,MAAA,EACA,YAAA,CAAa,CAAA;AAAA;AAAA;;AAMvB;AANuB,UAMN,cAAA;EAAA,OAAA;EAAA,IAAA,GAER,CAAA;EAAA,KAAA,GACC,WAAA;AAAA;AAAA;AAMV;AAaA;AAnBU,UAMO,WAAA;EAAA;EAAA,IAAA,EAET,YAAA;EAAA;EAAA,OAAA;EAAA;EAAA,OAAA;AAAA;AAAA;AAWR;AAkBA;;AA7BQ,aAWI,YAAA;EAAA;EAAA,EAAA;EAAA;EAAA,SAAA;EAAA;EAAA,iBAAA;EAAA;EAAA,QAAA;EAAA;EAAA,OAAA;EAAA;EAAA,aAAA;AAAA;AAAA;AAkBZ;;AAlBY,UAkBK,YAAA;EAAA,IAAA;IAAA,IAAA;IAAA,OAAA,GAGH,cAAA;EAAA;EAAA,IAAA;IAAA,IAAA;IAAA,OAAA,GAIA,cAAA;EAAA;EAAA,KAAA;IAAA,IAAA;IAAA,OAAA,EAID,oBAAA;IAAA,OAAA,GACC,eAAA;EAAA;EAAA,MAAA;IAAA,IAAA;IAAA,OAAA,GAIA,gBAAA;EAAA;EAAA,MAAA;IAAA,OAAA;IAAA,OAAA;IAAA,OAAA,GAKA,gBAAA;EAAA;EAAA,MAAA;IAAA,IAAA;IAAA,KAAA;IAAA,OAAA,GAKA,gBAAA;EAAA;EAAA,IAAA;IAAA,IAAA;IAAA,IAAA,EAIJ,MAAA;IAAA,OAAA,GACI,cAAA;EAAA;AAAA;AAAA;;AAOd;AAPc,UAOG,aAAA;EAAA,IAAA,EACT,aAAA;EAAA,IAAA,EACA,aAAA;EAAA,KAAA,EACC,cAAA;EAAA,MAAA,EACC,eAAA;EAAA,MAAA,EACA,eAAA;EAAA,MAAA,EACA,eAAA;EAAA,IAAA,EACF,aAAA;AAAA;AAAA;;AAMR;AANQ,cAMK,iBAAA,EAAmB,GAAA,CAAI,YAAA;AAAA;AAapC;AAOA;AApBoC,iBAapB,gBAAA,CAAA,MAAA,WAAA,MAAA,IAA4C,YAAA;AAAA;AAO5D;;AAP4D,iBAO5C,qBAAA,GAAA,CAAA,IAAA,EAA+B,CAAA,GAAI,cAAA,CAAe,CAAA;AAAA;;;AAAA,iBAUlD,mBAAA,CAAA,IAAA,EACR,YAAA,EAAA,OAAA,UAAA,OAAA,aAGL,cAAA"}

package/dist/protocol.mjs

@@ -0,0 +1,64 @@
+//#region src/protocol.ts
+/**
+* CLI-compatible error codes
+* @see https://github.com/arcblock/afs/blob/main/intent/specs/afs-cli-spec.md
+*/
+let AFSErrorCode = /* @__PURE__ */ function(AFSErrorCode) {
+	/** Operation successful */
+	AFSErrorCode[AFSErrorCode["OK"] = 0] = "OK";
+	/** Path not found */
+	AFSErrorCode[AFSErrorCode["NOT_FOUND"] = 1] = "NOT_FOUND";
+	/** Permission denied (including readonly mode) */
+	AFSErrorCode[AFSErrorCode["PERMISSION_DENIED"] = 2] = "PERMISSION_DENIED";
+	/** Concurrent modification conflict */
+	AFSErrorCode[AFSErrorCode["CONFLICT"] = 3] = "CONFLICT";
+	/** Partial success */
+	AFSErrorCode[AFSErrorCode["PARTIAL"] = 4] = "PARTIAL";
+	/** Runtime error */
+	AFSErrorCode[AFSErrorCode["RUNTIME_ERROR"] = 5] = "RUNTIME_ERROR";
+	return AFSErrorCode;
+}({});
+/**
+* Valid RPC methods set for validation
+*/
+const VALID_RPC_METHODS = new Set([
+	"list",
+	"read",
+	"write",
+	"delete",
+	"rename",
+	"search",
+	"exec"
+]);
+/**
+* Check if a string is a valid RPC method
+*/
+function isValidRpcMethod(method) {
+	return VALID_RPC_METHODS.has(method);
+}
+/**
+* Create a success response
+*/
+function createSuccessResponse(data) {
+	return {
+		success: true,
+		data
+	};
+}
+/**
+* Create an error response
+*/
+function createErrorResponse(code, message, details) {
+	return {
+		success: false,
+		error: {
+			code,
+			message,
+			details
+		}
+	};
+}
+
+//#endregion
+export { AFSErrorCode, VALID_RPC_METHODS, createErrorResponse, createSuccessResponse, isValidRpcMethod };
+//# sourceMappingURL=protocol.mjs.map

package/dist/protocol.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.mjs","names":[],"sources":["../src/protocol.ts"],"sourcesContent":["import type {\n  AFSDeleteOptions,\n  AFSDeleteResult,\n  AFSExecOptions,\n  AFSExecResult,\n  AFSListOptions,\n  AFSListResult,\n  AFSReadOptions,\n  AFSReadResult,\n  AFSRenameOptions,\n  AFSRenameResult,\n  AFSSearchOptions,\n  AFSSearchResult,\n  AFSWriteEntryPayload,\n  AFSWriteOptions,\n  AFSWriteResult,\n} from \"@aigne/afs\";\n\n/**\n * AFS HTTP RPC method names\n */\nexport type AFSRpcMethod = \"list\" | \"read\" | \"write\" | \"delete\" | \"rename\" | \"search\" | \"exec\";\n\n/**\n * RPC request body\n */\nexport interface AFSRpcRequest<M extends AFSRpcMethod = AFSRpcMethod> {\n  method: M;\n  params: AFSRpcParams[M];\n}\n\n/**\n * RPC response body\n */\nexport interface AFSRpcResponse<T = unknown> {\n  success: boolean;\n  data?: T;\n  error?: AFSRpcError;\n}\n\n/**\n * RPC error object\n */\nexport interface AFSRpcError {\n  /** CLI error code (0-5), compatible with AFS CLI */\n  code: AFSErrorCode;\n  /** Human-readable error message */\n  message: string;\n  /** Additional error details */\n  details?: unknown;\n}\n\n/**\n * CLI-compatible error codes\n * @see https://github.com/arcblock/afs/blob/main/intent/specs/afs-cli-spec.md\n */\nexport enum AFSErrorCode {\n  /** Operation successful */\n  OK = 0,\n  /** Path not found */\n  NOT_FOUND = 1,\n  /** Permission denied (including readonly mode) */\n  PERMISSION_DENIED = 2,\n  /** Concurrent modification conflict */\n  CONFLICT = 3,\n  /** Partial success */\n  PARTIAL = 4,\n  /** Runtime error */\n  RUNTIME_ERROR = 5,\n}\n\n/**\n * Parameter types for each RPC method\n */\nexport interface AFSRpcParams {\n  list: {\n    path: string;\n    options?: AFSListOptions;\n  };\n  read: {\n    path: string;\n    options?: AFSReadOptions;\n  };\n  write: {\n    path: string;\n    content: AFSWriteEntryPayload;\n    options?: AFSWriteOptions;\n  };\n  delete: {\n    path: string;\n    options?: AFSDeleteOptions;\n  };\n  rename: {\n    oldPath: string;\n    newPath: string;\n    options?: AFSRenameOptions;\n  };\n  search: {\n    path: string;\n    query: string;\n    options?: AFSSearchOptions;\n  };\n  exec: {\n    path: string;\n    args: Record<string, unknown>;\n    options?: AFSExecOptions;\n  };\n}\n\n/**\n * Result types for each RPC method\n */\nexport interface AFSRpcResults {\n  list: AFSListResult;\n  read: AFSReadResult;\n  write: AFSWriteResult;\n  delete: AFSDeleteResult;\n  rename: AFSRenameResult;\n  search: AFSSearchResult;\n  exec: AFSExecResult;\n}\n\n/**\n * Valid RPC methods set for validation\n */\nexport const VALID_RPC_METHODS: Set<AFSRpcMethod> = new Set([\n  \"list\",\n  \"read\",\n  \"write\",\n  \"delete\",\n  \"rename\",\n  \"search\",\n  \"exec\",\n]);\n\n/**\n * Check if a string is a valid RPC method\n */\nexport function isValidRpcMethod(method: string): method is AFSRpcMethod {\n  return VALID_RPC_METHODS.has(method as AFSRpcMethod);\n}\n\n/**\n * Create a success response\n */\nexport function createSuccessResponse<T>(data: T): AFSRpcResponse<T> {\n  return {\n    success: true,\n    data,\n  };\n}\n\n/**\n * Create an error response\n */\nexport function createErrorResponse(\n  code: AFSErrorCode,\n  message: string,\n  details?: unknown,\n): AFSRpcResponse<never> {\n  return {\n    success: false,\n    error: {\n      code,\n      message,\n      details,\n    },\n  };\n}\n"],"mappings":";;;;;AAwDA,IAAY,sDAAL;;AAEL;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;;;;;;AAyDF,MAAa,oBAAuC,IAAI,IAAI;CAC1D;CACA;CACA;CACA;CACA;CACA;CACA;CACD,CAAC;;;;AAKF,SAAgB,iBAAiB,QAAwC;AACvE,QAAO,kBAAkB,IAAI,OAAuB;;;;;AAMtD,SAAgB,sBAAyB,MAA4B;AACnE,QAAO;EACL,SAAS;EACT;EACD;;;;;AAMH,SAAgB,oBACd,MACA,SACA,SACuB;AACvB,QAAO;EACL,SAAS;EACT,OAAO;GACL;GACA;GACA;GACD;EACF"}