@aigne/afs-http 1.11.0-beta.3

package/dist/adapters/koa.d.cts

@@ -0,0 +1,56 @@
+import { Readable } from "node:stream";
+
+//#region src/adapters/koa.d.ts
+/**
+ * Koa-compatible context interface
+ */
+interface KoaContext {
+  method: string;
+  protocol: string;
+  host: string;
+  originalUrl: string;
+  request: {
+    body?: unknown;
+    headers: Record<string, string | string[] | undefined>;
+  };
+  req: Readable;
+  status: number;
+  body: string;
+  set(name: string, value: string): void;
+}
+/**
+ * Koa-compatible next function
+ */
+type KoaNext = () => Promise<void>;
+/**
+ * Koa-compatible middleware
+ */
+type KoaMiddleware = (ctx: KoaContext, next: KoaNext) => Promise<void>;
+/**
+ * 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());
+ * ```
+ */
+declare function koaAdapter(handler: (request: Request) => Promise<Response>): KoaMiddleware;
+//#endregion
+export { koaAdapter };
+//# sourceMappingURL=koa.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"koa.d.cts","names":[],"sources":["../../src/adapters/koa.ts"],"mappings":";;;;AAA4C;AAc7B;UATL,UAAA;EAAA,MAAA;EAAA,QAAA;EAAA,IAAA;EAAA,WAAA;EAAA,OAAA;IAAA,IAAA;IAAA,OAAA,EAOG,MAAA;EAAA;EAAA,GAAA,EAEN,QAAA;EAAA,MAAA;EAAA,IAAA;EAAA,GAAA,CAAA,IAAA,UAAA,KAAA;AAAA;AAAA;AAAQ;AASa;AATrB,KASF,OAAA,SAAgB,OAAA;AAAA;AAAO;;AAAP,KAKhB,aAAA,IAAA,GAAA,EAAsB,UAAA,EAAA,IAAA,EAAkB,OAAA,KAAY,OAAA;AAAA;;AAwDzD;;;;;;;;;;;;;;;;;;;;;;AAxDyD,iBAwDzC,UAAA,CAAA,OAAA,GAAA,OAAA,EAA8B,OAAA,KAAY,OAAA,CAAQ,QAAA,IAAY,aAAA"}

package/dist/adapters/koa.d.mts

@@ -0,0 +1,56 @@
+import { Readable } from "node:stream";
+
+//#region src/adapters/koa.d.ts
+/**
+ * Koa-compatible context interface
+ */
+interface KoaContext {
+  method: string;
+  protocol: string;
+  host: string;
+  originalUrl: string;
+  request: {
+    body?: unknown;
+    headers: Record<string, string | string[] | undefined>;
+  };
+  req: Readable;
+  status: number;
+  body: string;
+  set(name: string, value: string): void;
+}
+/**
+ * Koa-compatible next function
+ */
+type KoaNext = () => Promise<void>;
+/**
+ * Koa-compatible middleware
+ */
+type KoaMiddleware = (ctx: KoaContext, next: KoaNext) => Promise<void>;
+/**
+ * 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());
+ * ```
+ */
+declare function koaAdapter(handler: (request: Request) => Promise<Response>): KoaMiddleware;
+//#endregion
+export { koaAdapter };
+//# sourceMappingURL=koa.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"koa.d.mts","names":[],"sources":["../../src/adapters/koa.ts"],"mappings":";;;;AAA4C;AAc7B;UATL,UAAA;EAAA,MAAA;EAAA,QAAA;EAAA,IAAA;EAAA,WAAA;EAAA,OAAA;IAAA,IAAA;IAAA,OAAA,EAOG,MAAA;EAAA;EAAA,GAAA,EAEN,QAAA;EAAA,MAAA;EAAA,IAAA;EAAA,GAAA,CAAA,IAAA,UAAA,KAAA;AAAA;AAAA;AAAQ;AASa;AATrB,KASF,OAAA,SAAgB,OAAA;AAAA;AAAO;;AAAP,KAKhB,aAAA,IAAA,GAAA,EAAsB,UAAA,EAAA,IAAA,EAAkB,OAAA,KAAY,OAAA;AAAA;;AAwDzD;;;;;;;;;;;;;;;;;;;;;;AAxDyD,iBAwDzC,UAAA,CAAA,OAAA,GAAA,OAAA,EAA8B,OAAA,KAAY,OAAA,CAAQ,QAAA,IAAY,aAAA"}

package/dist/adapters/koa.mjs

@@ -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
+export { koaAdapter };
+//# sourceMappingURL=koa.mjs.map

package/dist/adapters/koa.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"koa.mjs","names":[],"sources":["../../src/adapters/koa.ts"],"sourcesContent":["import type { Readable } from \"node:stream\";\n\n/**\n * Koa-compatible context interface\n */\ninterface KoaContext {\n  method: string;\n  protocol: string;\n  host: string;\n  originalUrl: string;\n  request: {\n    body?: unknown;\n    headers: Record<string, string | string[] | undefined>;\n  };\n  req: Readable;\n  status: number;\n  body: string;\n  set(name: string, value: string): void;\n}\n\n/**\n * Koa-compatible next function\n */\ntype KoaNext = () => Promise<void>;\n\n/**\n * Koa-compatible middleware\n */\ntype KoaMiddleware = (ctx: KoaContext, next: KoaNext) => 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 Koa 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 * Koa adapter for AFS HTTP handler\n *\n * This adapter converts between Koa context and Web Standard Request/Response\n * objects, handling both scenarios where body parsing middleware is configured\n * (like koa-bodyparser) and where it isn't.\n *\n * @param handler - The AFS HTTP handler function\n * @returns A Koa-compatible middleware\n *\n * @example\n * ```typescript\n * import Koa from \"koa\";\n * import Router from \"@koa/router\";\n * import { createAFSHttpHandler, koaAdapter } from \"@aigne/afs-http\";\n *\n * const handler = createAFSHttpHandler({ module: provider });\n * const app = new Koa();\n * const router = new Router();\n *\n * router.post(\"/afs/rpc\", koaAdapter(handler));\n * app.use(router.routes());\n * ```\n */\nexport function koaAdapter(handler: (request: Request) => Promise<Response>): KoaMiddleware {\n  return async (ctx, _next) => {\n    // Build URL from context\n    const url = `${ctx.protocol}://${ctx.host}${ctx.originalUrl}`;\n\n    // Get body - handle both parsed and unparsed scenarios\n    let body: string | undefined;\n\n    if (ctx.method === \"POST\" || ctx.method === \"PUT\" || ctx.method === \"PATCH\") {\n      const requestBody = ctx.request.body;\n      if (\n        requestBody !== undefined &&\n        requestBody !== null &&\n        typeof requestBody === \"object\" &&\n        Object.keys(requestBody).length > 0\n      ) {\n        // Scenario 1: Body already parsed by middleware (e.g., koa-bodyparser)\n        body = JSON.stringify(requestBody);\n      } else {\n        // Scenario 2: Body not parsed, read from stream\n        body = await streamToString(ctx.req);\n      }\n    }\n\n    // Create Web Standard Request\n    const request = new Request(url, {\n      method: ctx.method,\n      headers: convertHeaders(ctx.request.headers),\n      body,\n    });\n\n    // Call the handler\n    const response = await handler(request);\n\n    // Write response back to Koa context\n    ctx.status = response.status;\n\n    // Copy headers\n    response.headers.forEach((value, key) => {\n      ctx.set(key, value);\n    });\n\n    // Set body\n    ctx.body = await response.text();\n  };\n}\n"],"mappings":";;;;AAiCA,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;;;;;;;;;;;;;;;;;;;;;;;;;;AA2BT,SAAgB,WAAW,SAAiE;AAC1F,QAAO,OAAO,KAAK,UAAU;EAE3B,MAAM,MAAM,GAAG,IAAI,SAAS,KAAK,IAAI,OAAO,IAAI;EAGhD,IAAI;AAEJ,MAAI,IAAI,WAAW,UAAU,IAAI,WAAW,SAAS,IAAI,WAAW,SAAS;GAC3E,MAAM,cAAc,IAAI,QAAQ;AAChC,OACE,gBAAgB,UAChB,gBAAgB,QAChB,OAAO,gBAAgB,YACvB,OAAO,KAAK,YAAY,CAAC,SAAS,EAGlC,QAAO,KAAK,UAAU,YAAY;OAGlC,QAAO,MAAM,eAAe,IAAI,IAAI;;EAYxC,MAAM,WAAW,MAAM,QAPP,IAAI,QAAQ,KAAK;GAC/B,QAAQ,IAAI;GACZ,SAAS,eAAe,IAAI,QAAQ,QAAQ;GAC5C;GACD,CAAC,CAGqC;AAGvC,MAAI,SAAS,SAAS;AAGtB,WAAS,QAAQ,SAAS,OAAO,QAAQ;AACvC,OAAI,IAAI,KAAK,MAAM;IACnB;AAGF,MAAI,OAAO,MAAM,SAAS,MAAM"}

package/dist/client.cjs

@@ -0,0 +1,143 @@
+const require_errors = require('./errors.cjs');
+const require_retry = require('./retry.cjs');
+
+//#region src/client.ts
+/**
+* Default client options
+*/
+const DEFAULT_CLIENT_OPTIONS = {
+	timeout: 3e4,
+	maxBodySize: 10 * 1024 * 1024,
+	accessMode: "readwrite"
+};
+/**
+* AFS HTTP Client
+*
+* Implements the AFSModule interface, forwarding all operations to a remote
+* AFS server via HTTP RPC calls.
+*
+* @example
+* ```typescript
+* import { AFS } from "@aigne/afs";
+* import { AFSHttpClient } from "@aigne/afs-http";
+*
+* const afs = new AFS();
+* afs.mount(
+*   new AFSHttpClient({
+*     url: "https://remote-afs.example.com/afs/rpc",
+*     name: "remote",
+*   })
+* );
+*
+* // Use like any local provider
+* const result = await afs.list("/modules/remote/some-path");
+* ```
+*/
+var AFSHttpClient = class {
+	name;
+	description;
+	accessMode;
+	url;
+	timeout;
+	maxBodySize;
+	retryOptions;
+	constructor(options) {
+		if (!options.url) throw new Error("AFSHttpClient requires a url option");
+		if (!options.name) throw new Error("AFSHttpClient requires a name option");
+		this.url = options.url.endsWith("/rpc") ? options.url : `${options.url}/rpc`;
+		this.name = options.name;
+		this.description = options.description;
+		this.accessMode = options.accessMode ?? DEFAULT_CLIENT_OPTIONS.accessMode;
+		this.timeout = options.timeout ?? DEFAULT_CLIENT_OPTIONS.timeout;
+		this.maxBodySize = options.maxBodySize ?? DEFAULT_CLIENT_OPTIONS.maxBodySize;
+		this.retryOptions = {
+			...require_retry.DEFAULT_RETRY_OPTIONS,
+			...options.retry
+		};
+	}
+	/**
+	* Make an RPC call to the remote server
+	*/
+	async rpc(method, params) {
+		const body = JSON.stringify({
+			method,
+			params
+		});
+		if (body.length > this.maxBodySize) throw new require_errors.AFSRuntimeError(`Request body too large: ${body.length} bytes exceeds limit of ${this.maxBodySize} bytes`);
+		let response;
+		try {
+			response = await require_retry.fetchWithRetry(this.url, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body,
+				signal: AbortSignal.timeout(this.timeout)
+			}, this.retryOptions);
+		} catch (error) {
+			throw new require_errors.AFSNetworkError(`Failed to connect to ${this.url}: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : void 0);
+		}
+		let result;
+		try {
+			result = await response.json();
+		} catch {
+			throw new require_errors.AFSRuntimeError(`Invalid response from server: expected JSON, got ${response.headers.get("content-type")}`);
+		}
+		if (!result.success) {
+			const error = result.error;
+			if (error) throw new require_errors.AFSRuntimeError(error.message || "Unknown error", {
+				code: error.code,
+				details: error.details
+			});
+			throw new require_errors.AFSRuntimeError("Request failed without error details");
+		}
+		return result.data;
+	}
+	async list(path, options) {
+		return this.rpc("list", {
+			path,
+			options
+		});
+	}
+	async read(path, options) {
+		return this.rpc("read", {
+			path,
+			options
+		});
+	}
+	async write(path, content, options) {
+		return this.rpc("write", {
+			path,
+			content,
+			options
+		});
+	}
+	async delete(path, options) {
+		return this.rpc("delete", {
+			path,
+			options
+		});
+	}
+	async rename(oldPath, newPath, options) {
+		return this.rpc("rename", {
+			oldPath,
+			newPath,
+			options
+		});
+	}
+	async search(path, query, options) {
+		return this.rpc("search", {
+			path,
+			query,
+			options
+		});
+	}
+	async exec(path, args, options) {
+		return this.rpc("exec", {
+			path,
+			args,
+			options
+		});
+	}
+};
+
+//#endregion
+exports.AFSHttpClient = AFSHttpClient;

package/dist/client.d.cts

@@ -0,0 +1,70 @@
+import { RetryOptions } from "./retry.cjs";
+import { AFSAccessMode, AFSDeleteOptions, AFSDeleteResult, AFSExecOptions, AFSExecResult, AFSListOptions, AFSListResult, AFSModule, AFSReadOptions, AFSReadResult, AFSRenameOptions, AFSRenameResult, AFSSearchOptions, AFSSearchResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+
+//#region src/client.d.ts
+/**
+ * Options for AFSHttpClient
+ */
+interface AFSHttpClientOptions {
+  /** Server URL (required) */
+  url: string;
+  /** Module name for mounting to AFS (required) */
+  name: string;
+  /** Module description (optional) */
+  description?: string;
+  /** Access mode (default: "readwrite") */
+  accessMode?: AFSAccessMode;
+  /** Request timeout in milliseconds (default: 30000) */
+  timeout?: number;
+  /** Maximum request body size in bytes (default: 10MB) */
+  maxBodySize?: number;
+  /** Retry configuration */
+  retry?: RetryOptions;
+}
+/**
+ * AFS HTTP Client
+ *
+ * Implements the AFSModule interface, forwarding all operations to a remote
+ * AFS server via HTTP RPC calls.
+ *
+ * @example
+ * ```typescript
+ * import { AFS } from "@aigne/afs";
+ * import { AFSHttpClient } from "@aigne/afs-http";
+ *
+ * const afs = new AFS();
+ * afs.mount(
+ *   new AFSHttpClient({
+ *     url: "https://remote-afs.example.com/afs/rpc",
+ *     name: "remote",
+ *   })
+ * );
+ *
+ * // Use like any local provider
+ * const result = await afs.list("/modules/remote/some-path");
+ * ```
+ */
+declare class AFSHttpClient implements AFSModule {
+  readonly name: string;
+  readonly description?: string;
+  readonly accessMode: AFSAccessMode;
+  private readonly url;
+  private readonly timeout;
+  private readonly maxBodySize;
+  private readonly retryOptions;
+  constructor(options: AFSHttpClientOptions);
+  /**
+       * Make an RPC call to the remote server
+       */
+  private rpc;
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;
+  write(path: string, content: AFSWriteEntryPayload, options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+  rename(oldPath: string, newPath: string, options?: AFSRenameOptions): Promise<AFSRenameResult>;
+  search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  exec(path: string, args: Record<string, unknown>, options: AFSExecOptions): Promise<AFSExecResult>;
+}
+//#endregion
+export { AFSHttpClient, AFSHttpClientOptions };
+//# sourceMappingURL=client.d.cts.map

package/dist/client.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.cts","names":[],"sources":["../src/client.ts"],"mappings":";;;;;AA0BA;AAiDA;UAjDiB,oBAAA;EAAA;EAAA,GAAA;EAAA;EAAA,IAAA;EAAA;EAAA,WAAA;EAAA;EAAA,UAAA,GAQF,aAAA;EAAA;EAAA,OAAA;EAAA;EAAA,WAAA;EAAA;EAAA,KAAA,GAML,YAAA;AAAA;AAAA;AAmCV;;;;;;;;;;;;;;;;;;;;;;AAnCU,cAmCG,aAAA,YAAyB,SAAA;EAAA,SAAA,IAAA;EAAA,SAAA,WAAA;EAAA,SAAA,UAAA,EAGf,aAAA;EAAA,iBAAA,GAAA;EAAA,iBAAA,OAAA;EAAA,iBAAA,WAAA;EAAA,iBAAA,YAAA;EAAA,YAAA,OAAA,EAOA,oBAAA;EAAA;;;EAAA,QAAA,GAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GAoFc,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GAIzB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,MAAA,IAAA,UAAA,OAAA,EAMjD,oBAAA,EAAA,OAAA,GACC,eAAA,GACT,OAAA,CAAQ,cAAA;EAAA,OAAA,IAAA,UAAA,OAAA,GAI0B,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA,OAAA,OAAA,UAAA,OAAA,UAAA,OAAA,GAOpD,gBAAA,GACT,OAAA,CAAQ,eAAA;EAAA,OAAA,IAAA,UAAA,KAAA,UAAA,OAAA,GAIyC,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA,KAAA,IAAA,UAAA,IAAA,EAMvE,MAAA,mBAAA,OAAA,EACG,cAAA,GACR,OAAA,CAAQ,aAAA;AAAA"}

package/dist/client.d.mts

@@ -0,0 +1,70 @@
+import { RetryOptions } from "./retry.mjs";
+import { AFSAccessMode, AFSDeleteOptions, AFSDeleteResult, AFSExecOptions, AFSExecResult, AFSListOptions, AFSListResult, AFSModule, AFSReadOptions, AFSReadResult, AFSRenameOptions, AFSRenameResult, AFSSearchOptions, AFSSearchResult, AFSWriteEntryPayload, AFSWriteOptions, AFSWriteResult } from "@aigne/afs";
+
+//#region src/client.d.ts
+/**
+ * Options for AFSHttpClient
+ */
+interface AFSHttpClientOptions {
+  /** Server URL (required) */
+  url: string;
+  /** Module name for mounting to AFS (required) */
+  name: string;
+  /** Module description (optional) */
+  description?: string;
+  /** Access mode (default: "readwrite") */
+  accessMode?: AFSAccessMode;
+  /** Request timeout in milliseconds (default: 30000) */
+  timeout?: number;
+  /** Maximum request body size in bytes (default: 10MB) */
+  maxBodySize?: number;
+  /** Retry configuration */
+  retry?: RetryOptions;
+}
+/**
+ * AFS HTTP Client
+ *
+ * Implements the AFSModule interface, forwarding all operations to a remote
+ * AFS server via HTTP RPC calls.
+ *
+ * @example
+ * ```typescript
+ * import { AFS } from "@aigne/afs";
+ * import { AFSHttpClient } from "@aigne/afs-http";
+ *
+ * const afs = new AFS();
+ * afs.mount(
+ *   new AFSHttpClient({
+ *     url: "https://remote-afs.example.com/afs/rpc",
+ *     name: "remote",
+ *   })
+ * );
+ *
+ * // Use like any local provider
+ * const result = await afs.list("/modules/remote/some-path");
+ * ```
+ */
+declare class AFSHttpClient implements AFSModule {
+  readonly name: string;
+  readonly description?: string;
+  readonly accessMode: AFSAccessMode;
+  private readonly url;
+  private readonly timeout;
+  private readonly maxBodySize;
+  private readonly retryOptions;
+  constructor(options: AFSHttpClientOptions);
+  /**
+       * Make an RPC call to the remote server
+       */
+  private rpc;
+  list(path: string, options?: AFSListOptions): Promise<AFSListResult>;
+  read(path: string, options?: AFSReadOptions): Promise<AFSReadResult>;
+  write(path: string, content: AFSWriteEntryPayload, options?: AFSWriteOptions): Promise<AFSWriteResult>;
+  delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+  rename(oldPath: string, newPath: string, options?: AFSRenameOptions): Promise<AFSRenameResult>;
+  search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  exec(path: string, args: Record<string, unknown>, options: AFSExecOptions): Promise<AFSExecResult>;
+}
+//#endregion
+export { AFSHttpClient, AFSHttpClientOptions };
+//# sourceMappingURL=client.d.mts.map

package/dist/client.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.mts","names":[],"sources":["../src/client.ts"],"mappings":";;;;;AA0BA;AAiDA;UAjDiB,oBAAA;EAAA;EAAA,GAAA;EAAA;EAAA,IAAA;EAAA;EAAA,WAAA;EAAA;EAAA,UAAA,GAQF,aAAA;EAAA;EAAA,OAAA;EAAA;EAAA,WAAA;EAAA;EAAA,KAAA,GAML,YAAA;AAAA;AAAA;AAmCV;;;;;;;;;;;;;;;;;;;;;;AAnCU,cAmCG,aAAA,YAAyB,SAAA;EAAA,SAAA,IAAA;EAAA,SAAA,WAAA;EAAA,SAAA,UAAA,EAGf,aAAA;EAAA,iBAAA,GAAA;EAAA,iBAAA,OAAA;EAAA,iBAAA,WAAA;EAAA,iBAAA,YAAA;EAAA,YAAA,OAAA,EAOA,oBAAA;EAAA;;;EAAA,QAAA,GAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GAoFc,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,KAAA,IAAA,UAAA,OAAA,GAIzB,cAAA,GAAiB,OAAA,CAAQ,aAAA;EAAA,MAAA,IAAA,UAAA,OAAA,EAMjD,oBAAA,EAAA,OAAA,GACC,eAAA,GACT,OAAA,CAAQ,cAAA;EAAA,OAAA,IAAA,UAAA,OAAA,GAI0B,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA,OAAA,OAAA,UAAA,OAAA,UAAA,OAAA,GAOpD,gBAAA,GACT,OAAA,CAAQ,eAAA;EAAA,OAAA,IAAA,UAAA,KAAA,UAAA,OAAA,GAIyC,gBAAA,GAAmB,OAAA,CAAQ,eAAA;EAAA,KAAA,IAAA,UAAA,IAAA,EAMvE,MAAA,mBAAA,OAAA,EACG,cAAA,GACR,OAAA,CAAQ,aAAA;AAAA"}

package/dist/client.mjs

@@ -0,0 +1,144 @@
+import { AFSNetworkError, AFSRuntimeError } from "./errors.mjs";
+import { DEFAULT_RETRY_OPTIONS, fetchWithRetry } from "./retry.mjs";
+
+//#region src/client.ts
+/**
+* Default client options
+*/
+const DEFAULT_CLIENT_OPTIONS = {
+	timeout: 3e4,
+	maxBodySize: 10 * 1024 * 1024,
+	accessMode: "readwrite"
+};
+/**
+* AFS HTTP Client
+*
+* Implements the AFSModule interface, forwarding all operations to a remote
+* AFS server via HTTP RPC calls.
+*
+* @example
+* ```typescript
+* import { AFS } from "@aigne/afs";
+* import { AFSHttpClient } from "@aigne/afs-http";
+*
+* const afs = new AFS();
+* afs.mount(
+*   new AFSHttpClient({
+*     url: "https://remote-afs.example.com/afs/rpc",
+*     name: "remote",
+*   })
+* );
+*
+* // Use like any local provider
+* const result = await afs.list("/modules/remote/some-path");
+* ```
+*/
+var AFSHttpClient = class {
+	name;
+	description;
+	accessMode;
+	url;
+	timeout;
+	maxBodySize;
+	retryOptions;
+	constructor(options) {
+		if (!options.url) throw new Error("AFSHttpClient requires a url option");
+		if (!options.name) throw new Error("AFSHttpClient requires a name option");
+		this.url = options.url.endsWith("/rpc") ? options.url : `${options.url}/rpc`;
+		this.name = options.name;
+		this.description = options.description;
+		this.accessMode = options.accessMode ?? DEFAULT_CLIENT_OPTIONS.accessMode;
+		this.timeout = options.timeout ?? DEFAULT_CLIENT_OPTIONS.timeout;
+		this.maxBodySize = options.maxBodySize ?? DEFAULT_CLIENT_OPTIONS.maxBodySize;
+		this.retryOptions = {
+			...DEFAULT_RETRY_OPTIONS,
+			...options.retry
+		};
+	}
+	/**
+	* Make an RPC call to the remote server
+	*/
+	async rpc(method, params) {
+		const body = JSON.stringify({
+			method,
+			params
+		});
+		if (body.length > this.maxBodySize) throw new AFSRuntimeError(`Request body too large: ${body.length} bytes exceeds limit of ${this.maxBodySize} bytes`);
+		let response;
+		try {
+			response = await fetchWithRetry(this.url, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body,
+				signal: AbortSignal.timeout(this.timeout)
+			}, this.retryOptions);
+		} catch (error) {
+			throw new AFSNetworkError(`Failed to connect to ${this.url}: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? error : void 0);
+		}
+		let result;
+		try {
+			result = await response.json();
+		} catch {
+			throw new AFSRuntimeError(`Invalid response from server: expected JSON, got ${response.headers.get("content-type")}`);
+		}
+		if (!result.success) {
+			const error = result.error;
+			if (error) throw new AFSRuntimeError(error.message || "Unknown error", {
+				code: error.code,
+				details: error.details
+			});
+			throw new AFSRuntimeError("Request failed without error details");
+		}
+		return result.data;
+	}
+	async list(path, options) {
+		return this.rpc("list", {
+			path,
+			options
+		});
+	}
+	async read(path, options) {
+		return this.rpc("read", {
+			path,
+			options
+		});
+	}
+	async write(path, content, options) {
+		return this.rpc("write", {
+			path,
+			content,
+			options
+		});
+	}
+	async delete(path, options) {
+		return this.rpc("delete", {
+			path,
+			options
+		});
+	}
+	async rename(oldPath, newPath, options) {
+		return this.rpc("rename", {
+			oldPath,
+			newPath,
+			options
+		});
+	}
+	async search(path, query, options) {
+		return this.rpc("search", {
+			path,
+			query,
+			options
+		});
+	}
+	async exec(path, args, options) {
+		return this.rpc("exec", {
+			path,
+			args,
+			options
+		});
+	}
+};
+
+//#endregion
+export { AFSHttpClient };
+//# sourceMappingURL=client.mjs.map

package/dist/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.mjs","names":[],"sources":["../src/client.ts"],"sourcesContent":["import type {\n  AFSAccessMode,\n  AFSDeleteOptions,\n  AFSDeleteResult,\n  AFSExecOptions,\n  AFSExecResult,\n  AFSListOptions,\n  AFSListResult,\n  AFSModule,\n  AFSReadOptions,\n  AFSReadResult,\n  AFSRenameOptions,\n  AFSRenameResult,\n  AFSSearchOptions,\n  AFSSearchResult,\n  AFSWriteEntryPayload,\n  AFSWriteOptions,\n  AFSWriteResult,\n} from \"@aigne/afs\";\nimport { AFSNetworkError, AFSRuntimeError } from \"./errors.js\";\nimport type { AFSRpcMethod, AFSRpcResponse, AFSRpcResults } from \"./protocol.js\";\nimport { DEFAULT_RETRY_OPTIONS, fetchWithRetry, type RetryOptions } from \"./retry.js\";\n\n/**\n * Options for AFSHttpClient\n */\nexport interface AFSHttpClientOptions {\n  /** Server URL (required) */\n  url: string;\n  /** Module name for mounting to AFS (required) */\n  name: string;\n  /** Module description (optional) */\n  description?: string;\n  /** Access mode (default: \"readwrite\") */\n  accessMode?: AFSAccessMode;\n  /** Request timeout in milliseconds (default: 30000) */\n  timeout?: number;\n  /** Maximum request body size in bytes (default: 10MB) */\n  maxBodySize?: number;\n  /** Retry configuration */\n  retry?: RetryOptions;\n}\n\n/**\n * Default client options\n */\nconst DEFAULT_CLIENT_OPTIONS = {\n  timeout: 30000,\n  maxBodySize: 10 * 1024 * 1024, // 10MB\n  accessMode: \"readwrite\" as AFSAccessMode,\n};\n\n/**\n * AFS HTTP Client\n *\n * Implements the AFSModule interface, forwarding all operations to a remote\n * AFS server via HTTP RPC calls.\n *\n * @example\n * ```typescript\n * import { AFS } from \"@aigne/afs\";\n * import { AFSHttpClient } from \"@aigne/afs-http\";\n *\n * const afs = new AFS();\n * afs.mount(\n *   new AFSHttpClient({\n *     url: \"https://remote-afs.example.com/afs/rpc\",\n *     name: \"remote\",\n *   })\n * );\n *\n * // Use like any local provider\n * const result = await afs.list(\"/modules/remote/some-path\");\n * ```\n */\nexport class AFSHttpClient implements AFSModule {\n  readonly name: string;\n  readonly description?: string;\n  readonly accessMode: AFSAccessMode;\n\n  private readonly url: string;\n  private readonly timeout: number;\n  private readonly maxBodySize: number;\n  private readonly retryOptions: RetryOptions;\n\n  constructor(options: AFSHttpClientOptions) {\n    if (!options.url) {\n      throw new Error(\"AFSHttpClient requires a url option\");\n    }\n    if (!options.name) {\n      throw new Error(\"AFSHttpClient requires a name option\");\n    }\n\n    this.url = options.url.endsWith(\"/rpc\") ? options.url : `${options.url}/rpc`;\n    this.name = options.name;\n    this.description = options.description;\n    this.accessMode = options.accessMode ?? DEFAULT_CLIENT_OPTIONS.accessMode;\n    this.timeout = options.timeout ?? DEFAULT_CLIENT_OPTIONS.timeout;\n    this.maxBodySize = options.maxBodySize ?? DEFAULT_CLIENT_OPTIONS.maxBodySize;\n    this.retryOptions = {\n      ...DEFAULT_RETRY_OPTIONS,\n      ...options.retry,\n    };\n  }\n\n  /**\n   * Make an RPC call to the remote server\n   */\n  private async rpc<M extends AFSRpcMethod>(\n    method: M,\n    params: Record<string, unknown>,\n  ): Promise<AFSRpcResults[M]> {\n    const body = JSON.stringify({ method, params });\n\n    // Check body size before sending\n    if (body.length > this.maxBodySize) {\n      throw new AFSRuntimeError(\n        `Request body too large: ${body.length} bytes exceeds limit of ${this.maxBodySize} bytes`,\n      );\n    }\n\n    let response: Response;\n    try {\n      response = await fetchWithRetry(\n        this.url,\n        {\n          method: \"POST\",\n          headers: {\n            \"Content-Type\": \"application/json\",\n          },\n          body,\n          signal: AbortSignal.timeout(this.timeout),\n        },\n        this.retryOptions,\n      );\n    } catch (error) {\n      throw new AFSNetworkError(\n        `Failed to connect to ${this.url}: ${error instanceof Error ? error.message : String(error)}`,\n        error instanceof Error ? error : undefined,\n      );\n    }\n\n    // Parse response\n    let result: AFSRpcResponse<AFSRpcResults[M]>;\n    try {\n      result = await response.json();\n    } catch {\n      throw new AFSRuntimeError(\n        `Invalid response from server: expected JSON, got ${response.headers.get(\"content-type\")}`,\n      );\n    }\n\n    // Check for RPC-level errors\n    if (!result.success) {\n      const error = result.error;\n      if (error) {\n        // Re-throw with the appropriate error type based on code\n        const errorMessage = error.message || \"Unknown error\";\n        throw new AFSRuntimeError(errorMessage, {\n          code: error.code,\n          details: error.details,\n        });\n      }\n      throw new AFSRuntimeError(\"Request failed without error details\");\n    }\n\n    return result.data as AFSRpcResults[M];\n  }\n\n  async list(path: string, options?: AFSListOptions): Promise<AFSListResult> {\n    return this.rpc(\"list\", { path, options });\n  }\n\n  async read(path: string, options?: AFSReadOptions): Promise<AFSReadResult> {\n    return this.rpc(\"read\", { path, options });\n  }\n\n  async write(\n    path: string,\n    content: AFSWriteEntryPayload,\n    options?: AFSWriteOptions,\n  ): Promise<AFSWriteResult> {\n    return this.rpc(\"write\", { path, content, options });\n  }\n\n  async delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult> {\n    return this.rpc(\"delete\", { path, options });\n  }\n\n  async rename(\n    oldPath: string,\n    newPath: string,\n    options?: AFSRenameOptions,\n  ): Promise<AFSRenameResult> {\n    return this.rpc(\"rename\", { oldPath, newPath, options });\n  }\n\n  async search(path: string, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult> {\n    return this.rpc(\"search\", { path, query, options });\n  }\n\n  async exec(\n    path: string,\n    args: Record<string, unknown>,\n    options: AFSExecOptions,\n  ): Promise<AFSExecResult> {\n    return this.rpc(\"exec\", { path, args, options });\n  }\n}\n"],"mappings":";;;;;;;AA8CA,MAAM,yBAAyB;CAC7B,SAAS;CACT,aAAa,KAAK,OAAO;CACzB,YAAY;CACb;;;;;;;;;;;;;;;;;;;;;;;;AAyBD,IAAa,gBAAb,MAAgD;CAC9C,AAAS;CACT,AAAS;CACT,AAAS;CAET,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CACjB,AAAiB;CAEjB,YAAY,SAA+B;AACzC,MAAI,CAAC,QAAQ,IACX,OAAM,IAAI,MAAM,sCAAsC;AAExD,MAAI,CAAC,QAAQ,KACX,OAAM,IAAI,MAAM,uCAAuC;AAGzD,OAAK,MAAM,QAAQ,IAAI,SAAS,OAAO,GAAG,QAAQ,MAAM,GAAG,QAAQ,IAAI;AACvE,OAAK,OAAO,QAAQ;AACpB,OAAK,cAAc,QAAQ;AAC3B,OAAK,aAAa,QAAQ,cAAc,uBAAuB;AAC/D,OAAK,UAAU,QAAQ,WAAW,uBAAuB;AACzD,OAAK,cAAc,QAAQ,eAAe,uBAAuB;AACjE,OAAK,eAAe;GAClB,GAAG;GACH,GAAG,QAAQ;GACZ;;;;;CAMH,MAAc,IACZ,QACA,QAC2B;EAC3B,MAAM,OAAO,KAAK,UAAU;GAAE;GAAQ;GAAQ,CAAC;AAG/C,MAAI,KAAK,SAAS,KAAK,YACrB,OAAM,IAAI,gBACR,2BAA2B,KAAK,OAAO,0BAA0B,KAAK,YAAY,QACnF;EAGH,IAAI;AACJ,MAAI;AACF,cAAW,MAAM,eACf,KAAK,KACL;IACE,QAAQ;IACR,SAAS,EACP,gBAAgB,oBACjB;IACD;IACA,QAAQ,YAAY,QAAQ,KAAK,QAAQ;IAC1C,EACD,KAAK,aACN;WACM,OAAO;AACd,SAAM,IAAI,gBACR,wBAAwB,KAAK,IAAI,IAAI,iBAAiB,QAAQ,MAAM,UAAU,OAAO,MAAM,IAC3F,iBAAiB,QAAQ,QAAQ,OAClC;;EAIH,IAAI;AACJ,MAAI;AACF,YAAS,MAAM,SAAS,MAAM;UACxB;AACN,SAAM,IAAI,gBACR,oDAAoD,SAAS,QAAQ,IAAI,eAAe,GACzF;;AAIH,MAAI,CAAC,OAAO,SAAS;GACnB,MAAM,QAAQ,OAAO;AACrB,OAAI,MAGF,OAAM,IAAI,gBADW,MAAM,WAAW,iBACE;IACtC,MAAM,MAAM;IACZ,SAAS,MAAM;IAChB,CAAC;AAEJ,SAAM,IAAI,gBAAgB,uCAAuC;;AAGnE,SAAO,OAAO;;CAGhB,MAAM,KAAK,MAAc,SAAkD;AACzE,SAAO,KAAK,IAAI,QAAQ;GAAE;GAAM;GAAS,CAAC;;CAG5C,MAAM,KAAK,MAAc,SAAkD;AACzE,SAAO,KAAK,IAAI,QAAQ;GAAE;GAAM;GAAS,CAAC;;CAG5C,MAAM,MACJ,MACA,SACA,SACyB;AACzB,SAAO,KAAK,IAAI,SAAS;GAAE;GAAM;GAAS;GAAS,CAAC;;CAGtD,MAAM,OAAO,MAAc,SAAsD;AAC/E,SAAO,KAAK,IAAI,UAAU;GAAE;GAAM;GAAS,CAAC;;CAG9C,MAAM,OACJ,SACA,SACA,SAC0B;AAC1B,SAAO,KAAK,IAAI,UAAU;GAAE;GAAS;GAAS;GAAS,CAAC;;CAG1D,MAAM,OAAO,MAAc,OAAe,SAAsD;AAC9F,SAAO,KAAK,IAAI,UAAU;GAAE;GAAM;GAAO;GAAS,CAAC;;CAGrD,MAAM,KACJ,MACA,MACA,SACwB;AACxB,SAAO,KAAK,IAAI,QAAQ;GAAE;GAAM;GAAM;GAAS,CAAC"}