@aigne/afs-explorer 1.11.0-beta.10 → 1.11.0-beta.12

package/dist/_virtual/rolldown_runtime.mjs

@@ -0,0 +1,7 @@
+import { createRequire } from "node:module";
+
+//#region rolldown:runtime
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+export { __require };

package/dist/index.cjs

@@ -1,20 +1,20 @@
-const require_server = require('./server.cjs');
+const require_ws_server = require('./ws-server.cjs');
 
 //#region src/index.ts
 /**
-* Start the AFS Explorer web server
+* Start the AFS Explorer web server (Bun.serve + WebSocket JSON-RPC)
 * @param afs - The AFS instance to explore
 * @param options - Server options
-* @returns The ExplorerServer instance
+* @returns Object with port, url, and stop function
 */
 async function startExplorer(afs, options = {}) {
-	const server = new require_server.ExplorerServer(afs, options);
-	await server.start();
-	return server;
+	const server = new require_ws_server.ExplorerWSServer(afs, options);
+	return {
+		...await server.start(),
+		stop: () => server.stop()
+	};
 }
 
 //#endregion
-exports.ExplorerServer = require_server.ExplorerServer;
-exports.createExplorerMiddleware = require_server.createExplorerMiddleware;
-exports.createExplorerRouter = require_server.createExplorerRouter;
+exports.ExplorerWSServer = require_ws_server.ExplorerWSServer;
 exports.startExplorer = startExplorer;

package/dist/index.d.cts

@@ -1,14 +1,18 @@
-import { ExplorerMiddlewareOptions, ExplorerRouterOptions, ExplorerServer, ExplorerServerOptions, createExplorerMiddleware, createExplorerRouter } from "./server.cjs";
+import { ConfigManager, ExplorerWSServer, WSServerOptions } from "./ws-server.cjs";
 import { AFS } from "@aigne/afs";
 
 //#region src/index.d.ts
 /**
- * Start the AFS Explorer web server
+ * Start the AFS Explorer web server (Bun.serve + WebSocket JSON-RPC)
  * @param afs - The AFS instance to explore
  * @param options - Server options
- * @returns The ExplorerServer instance
+ * @returns Object with port, url, and stop function
  */
-declare function startExplorer(afs: AFS, options?: ExplorerServerOptions): Promise<ExplorerServer>;
+declare function startExplorer(afs: AFS, options?: WSServerOptions): Promise<{
+  port: number;
+  url: string;
+  stop: () => void;
+}>;
 //#endregion
-export { type ExplorerMiddlewareOptions, type ExplorerRouterOptions, ExplorerServer, type ExplorerServerOptions, createExplorerMiddleware, createExplorerRouter, startExplorer };
+export { type ConfigManager, ExplorerWSServer, type WSServerOptions, startExplorer };
 //# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;AAyBA;;;;;iBAAsB,aAAA,CACpB,GAAA,EAAK,GAAA,EACL,OAAA,GAAS,qBAAA,GACR,OAAA,CAAQ,cAAA"}
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;AAWA;;;;;iBAAsB,aAAA,CACpB,GAAA,EAAK,GAAA,EACL,OAAA,GAAS,eAAA,GACR,OAAA;EAAU,IAAA;EAAc,GAAA;EAAa,IAAA;AAAA"}

package/dist/index.d.mts

@@ -1,14 +1,18 @@
-import { ExplorerMiddlewareOptions, ExplorerRouterOptions, ExplorerServer, ExplorerServerOptions, createExplorerMiddleware, createExplorerRouter } from "./server.mjs";
+import { ConfigManager, ExplorerWSServer, WSServerOptions } from "./ws-server.mjs";
 import { AFS } from "@aigne/afs";
 
 //#region src/index.d.ts
 /**
- * Start the AFS Explorer web server
+ * Start the AFS Explorer web server (Bun.serve + WebSocket JSON-RPC)
  * @param afs - The AFS instance to explore
  * @param options - Server options
- * @returns The ExplorerServer instance
+ * @returns Object with port, url, and stop function
  */
-declare function startExplorer(afs: AFS, options?: ExplorerServerOptions): Promise<ExplorerServer>;
+declare function startExplorer(afs: AFS, options?: WSServerOptions): Promise<{
+  port: number;
+  url: string;
+  stop: () => void;
+}>;
 //#endregion
-export { type ExplorerMiddlewareOptions, type ExplorerRouterOptions, ExplorerServer, type ExplorerServerOptions, createExplorerMiddleware, createExplorerRouter, startExplorer };
+export { type ConfigManager, ExplorerWSServer, type WSServerOptions, startExplorer };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;AAyBA;;;;;iBAAsB,aAAA,CACpB,GAAA,EAAK,GAAA,EACL,OAAA,GAAS,qBAAA,GACR,OAAA,CAAQ,cAAA"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;AAWA;;;;;iBAAsB,aAAA,CACpB,GAAA,EAAK,GAAA,EACL,OAAA,GAAS,eAAA,GACR,OAAA;EAAU,IAAA;EAAc,GAAA;EAAa,IAAA;AAAA"}

package/dist/index.mjs

@@ -1,18 +1,20 @@
-import { ExplorerServer, createExplorerMiddleware, createExplorerRouter } from "./server.mjs";
+import { ExplorerWSServer } from "./ws-server.mjs";
 
 //#region src/index.ts
 /**
-* Start the AFS Explorer web server
+* Start the AFS Explorer web server (Bun.serve + WebSocket JSON-RPC)
 * @param afs - The AFS instance to explore
 * @param options - Server options
-* @returns The ExplorerServer instance
+* @returns Object with port, url, and stop function
 */
 async function startExplorer(afs, options = {}) {
-	const server = new ExplorerServer(afs, options);
-	await server.start();
-	return server;
+	const server = new ExplorerWSServer(afs, options);
+	return {
+		...await server.start(),
+		stop: () => server.stop()
+	};
 }
 
 //#endregion
-export { ExplorerServer, createExplorerMiddleware, createExplorerRouter, startExplorer };
+export { ExplorerWSServer, startExplorer };
 //# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { AFS } from \"@aigne/afs\";\nimport {\n  createExplorerMiddleware,\n  createExplorerRouter,\n  type ExplorerMiddlewareOptions,\n  type ExplorerRouterOptions,\n  ExplorerServer,\n  type ExplorerServerOptions,\n} from \"./server.js\";\n\nexport {\n  ExplorerServer,\n  type ExplorerServerOptions,\n  createExplorerRouter,\n  createExplorerMiddleware,\n  type ExplorerRouterOptions,\n  type ExplorerMiddlewareOptions,\n};\n\n/**\n * Start the AFS Explorer web server\n * @param afs - The AFS instance to explore\n * @param options - Server options\n * @returns The ExplorerServer instance\n */\nexport async function startExplorer(\n  afs: AFS,\n  options: ExplorerServerOptions = {},\n): Promise<ExplorerServer> {\n  const server = new ExplorerServer(afs, options);\n  await server.start();\n  return server;\n}\n"],"mappings":";;;;;;;;;AAyBA,eAAsB,cACpB,KACA,UAAiC,EAAE,EACV;CACzB,MAAM,SAAS,IAAI,eAAe,KAAK,QAAQ;AAC/C,OAAM,OAAO,OAAO;AACpB,QAAO"}
+{"version":3,"file":"index.mjs","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { AFS } from \"@aigne/afs\";\nimport { type ConfigManager, ExplorerWSServer, type WSServerOptions } from \"./ws-server.js\";\n\nexport { ExplorerWSServer, type ConfigManager, type WSServerOptions };\n\n/**\n * Start the AFS Explorer web server (Bun.serve + WebSocket JSON-RPC)\n * @param afs - The AFS instance to explore\n * @param options - Server options\n * @returns Object with port, url, and stop function\n */\nexport async function startExplorer(\n  afs: AFS,\n  options: WSServerOptions = {},\n): Promise<{ port: number; url: string; stop: () => void }> {\n  const server = new ExplorerWSServer(afs, options);\n  const info = await server.start();\n  return { ...info, stop: () => server.stop() };\n}\n"],"mappings":";;;;;;;;;AAWA,eAAsB,cACpB,KACA,UAA2B,EAAE,EAC6B;CAC1D,MAAM,SAAS,IAAI,iBAAiB,KAAK,QAAQ;AAEjD,QAAO;EAAE,GADI,MAAM,OAAO,OAAO;EACf,YAAY,OAAO,MAAM;EAAE"}

package/dist/ws-server.cjs

@@ -0,0 +1,493 @@
+let node_fs = require("node:fs");
+let node_http = require("node:http");
+let node_path = require("node:path");
+
+//#region src/ws-server.ts
+const MIME_TYPES = {
+	".html": "text/html; charset=utf-8",
+	".js": "application/javascript; charset=utf-8",
+	".css": "text/css; charset=utf-8",
+	".json": "application/json; charset=utf-8",
+	".svg": "image/svg+xml",
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".bmp": "image/bmp",
+	".ico": "image/x-icon",
+	".pdf": "application/pdf",
+	".md": "text/markdown; charset=utf-8",
+	".txt": "text/plain; charset=utf-8"
+};
+function getMimeType(fileName) {
+	return MIME_TYPES[fileName.slice(fileName.lastIndexOf("."))] || "application/octet-stream";
+}
+var ExplorerWSServer = class {
+	httpServer;
+	wss;
+	afs;
+	options;
+	constructor(afs, options = {}) {
+		this.afs = afs;
+		this.options = options;
+	}
+	/**
+	* Broadcast a JSON-RPC notification to all connected WebSocket clients.
+	*/
+	broadcast(method, params) {
+		if (!this.wss) return;
+		const message = JSON.stringify({
+			method,
+			params
+		});
+		for (const client of this.wss.clients) if (client.readyState === 1) client.send(message);
+	}
+	async start() {
+		const port = this.options.port || 0;
+		const host = this.options.host || "localhost";
+		const afs = this.afs;
+		const opts = this.options;
+		const configManager = this.options.configManager;
+		const httpMiddleware = this.options.httpMiddleware;
+		const { WebSocketServer } = await import("ws");
+		const httpServer = (0, node_http.createServer)(async (req, res) => {
+			const url = new URL(req.url || "/", `http://${req.headers.host}`);
+			if (httpMiddleware) {
+				if (await httpMiddleware(req, res)) return;
+			}
+			if (url.pathname === "/api/read") {
+				const afsPath = url.searchParams.get("path");
+				if (!afsPath) {
+					res.writeHead(400);
+					res.end("Missing path parameter");
+					return;
+				}
+				try {
+					const content = (await afs.read(afsPath)).data?.content;
+					const mime = MIME_TYPES[afsPath.slice(afsPath.lastIndexOf("."))] || "application/octet-stream";
+					if (content instanceof Buffer || content instanceof Uint8Array) {
+						res.writeHead(200, {
+							"Content-Type": mime,
+							"Cache-Control": "no-cache"
+						});
+						res.end(Buffer.from(content));
+					} else if (content instanceof ArrayBuffer) {
+						res.writeHead(200, {
+							"Content-Type": mime,
+							"Cache-Control": "no-cache"
+						});
+						res.end(Buffer.from(new Uint8Array(content)));
+					} else {
+						const text = typeof content === "string" ? content : content !== void 0 && content !== null ? JSON.stringify(content, null, 2) : "";
+						res.writeHead(200, {
+							"Content-Type": mime.includes("charset") ? mime : `${mime}; charset=utf-8`,
+							"Cache-Control": "no-cache"
+						});
+						res.end(text);
+					}
+				} catch (err) {
+					res.writeHead(500);
+					res.end(err instanceof Error ? err.message : String(err));
+				}
+				return;
+			}
+			let fileName = url.pathname === "/" ? "index.html" : url.pathname.slice(1);
+			fileName = fileName.replace(/\.\./g, "");
+			serveStatic(fileName, opts, res);
+		});
+		const wss = new WebSocketServer({
+			server: httpServer,
+			path: "/ws"
+		});
+		this.wss = wss;
+		wss.on("connection", (ws) => {
+			ws.on("message", async (raw) => {
+				let req;
+				try {
+					const text = typeof raw === "string" ? raw : raw.toString("utf-8");
+					req = JSON.parse(text);
+				} catch {
+					ws.send(JSON.stringify({
+						id: null,
+						error: {
+							code: -32700,
+							message: "Parse error"
+						}
+					}));
+					return;
+				}
+				if (!req.method || req.id === void 0) {
+					ws.send(JSON.stringify({
+						id: req.id ?? null,
+						error: {
+							code: -32600,
+							message: "Invalid request"
+						}
+					}));
+					return;
+				}
+				const response = await handleRPC(afs, req, configManager);
+				ws.send(JSON.stringify(response));
+			});
+		});
+		this.httpServer = httpServer;
+		return new Promise((resolve) => {
+			httpServer.listen(port, host, () => {
+				const addr = httpServer.address();
+				const actualPort = typeof addr === "object" && addr ? addr.port : port;
+				const serverUrl = `http://${host}:${actualPort}`;
+				if (opts.open) {
+					const { exec } = require("node:child_process");
+					exec(`${process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open"} ${serverUrl}`);
+				}
+				resolve({
+					port: actualPort,
+					url: serverUrl
+				});
+			});
+		});
+	}
+	stop() {
+		if (this.wss) {
+			this.wss.close();
+			this.wss = void 0;
+		}
+		if (this.httpServer) {
+			this.httpServer.close();
+			this.httpServer = void 0;
+		}
+	}
+};
+function serveStatic(fileName, opts, res) {
+	if (opts.embeddedAssets && fileName in opts.embeddedAssets) {
+		res.writeHead(200, { "Content-Type": getMimeType(fileName) });
+		res.end(opts.embeddedAssets[fileName]);
+		return;
+	}
+	if (opts.webRoot) {
+		const filePath = (0, node_path.join)(opts.webRoot, fileName);
+		if ((0, node_fs.existsSync)(filePath)) {
+			const content = (0, node_fs.readFileSync)(filePath);
+			res.writeHead(200, {
+				"Content-Type": getMimeType(fileName),
+				"Cache-Control": "no-cache"
+			});
+			res.end(content);
+			return;
+		}
+	}
+	res.writeHead(404);
+	res.end("Not Found");
+}
+async function handleRPC(afs, req, configManager) {
+	const params = req.params || {};
+	try {
+		switch (req.method) {
+			case "list": {
+				const path = params.path || "/";
+				const maxDepth = params.maxDepth ?? 1;
+				const result = await afs.list(path, { maxDepth });
+				return {
+					id: req.id,
+					result: { list: result.data }
+				};
+			}
+			case "read": {
+				const path = params.path;
+				if (!path) return {
+					id: req.id,
+					error: {
+						code: -32602,
+						message: "path is required"
+					}
+				};
+				const entry = (await afs.read(path)).data;
+				let content = entry?.content;
+				if (content instanceof Buffer || content instanceof Uint8Array) content = new TextDecoder().decode(content);
+				else if (content instanceof ArrayBuffer) content = new TextDecoder().decode(new Uint8Array(content));
+				else if (typeof content === "object" && content !== null) content = JSON.stringify(content, null, 2);
+				else if (content !== void 0 && typeof content !== "string") content = String(content);
+				return {
+					id: req.id,
+					result: {
+						content,
+						entry
+					}
+				};
+			}
+			case "stat": {
+				const path = params.path;
+				if (!path) return {
+					id: req.id,
+					error: {
+						code: -32602,
+						message: "path is required"
+					}
+				};
+				const result = await afs.stat(path);
+				return {
+					id: req.id,
+					result: result.data || null
+				};
+			}
+			case "search": {
+				const path = params.path || "/";
+				const pattern = params.pattern;
+				if (!pattern) return {
+					id: req.id,
+					error: {
+						code: -32602,
+						message: "pattern is required"
+					}
+				};
+				const result = await afs.search(path, pattern);
+				return {
+					id: req.id,
+					result
+				};
+			}
+			case "exec": {
+				const path = params.path;
+				if (!path) return {
+					id: req.id,
+					error: {
+						code: -32602,
+						message: "path is required"
+					}
+				};
+				const args = params.args || {};
+				const result = await afs.exec(path, args, {});
+				return {
+					id: req.id,
+					result
+				};
+			}
+			case "explain": {
+				const path = params.path;
+				if (!path) return {
+					id: req.id,
+					error: {
+						code: -32602,
+						message: "path is required"
+					}
+				};
+				const result = await afs.stat(path);
+				return {
+					id: req.id,
+					result: result.data || null
+				};
+			}
+			case "write": {
+				const path = params.path;
+				if (!path) return {
+					id: req.id,
+					error: {
+						code: -32602,
+						message: "path is required"
+					}
+				};
+				const content = params.content;
+				await afs.write(path, { content });
+				return {
+					id: req.id,
+					result: { success: true }
+				};
+			}
+			case "delete": {
+				const path = params.path;
+				if (!path) return {
+					id: req.id,
+					error: {
+						code: -32602,
+						message: "path is required"
+					}
+				};
+				const result = await afs.delete(path);
+				return {
+					id: req.id,
+					result
+				};
+			}
+			case "getMounts": {
+				const mounts = afs.getMounts();
+				const mountInfos = await Promise.all(mounts.map(async (m) => {
+					const ctor = m.module.constructor;
+					const manifest = typeof ctor.manifest === "function" ? ctor.manifest() : null;
+					let url;
+					try {
+						if (typeof m.module.stat === "function") url = (await m.module.stat("/", {}))?.data?.meta?.url || void 0;
+					} catch {}
+					return {
+						namespace: m.namespace,
+						path: m.path,
+						name: m.module.name,
+						description: m.module.description,
+						accessMode: m.module.accessMode,
+						category: manifest?.category || void 0,
+						tags: manifest?.tags || void 0,
+						url
+					};
+				}));
+				return {
+					id: req.id,
+					result: { mounts: mountInfos }
+				};
+			}
+			case "mount.list": {
+				if (!configManager) return {
+					id: req.id,
+					error: {
+						code: -32601,
+						message: "Mount management not available"
+					}
+				};
+				const result = await configManager.getMountList();
+				return {
+					id: req.id,
+					result
+				};
+			}
+			case "mount.add":
+				if (!configManager) return {
+					id: req.id,
+					error: {
+						code: -32601,
+						message: "Mount management not available"
+					}
+				};
+				await configManager.addMount(params);
+				return {
+					id: req.id,
+					result: { success: true }
+				};
+			case "mount.remove": {
+				if (!configManager) return {
+					id: req.id,
+					error: {
+						code: -32601,
+						message: "Mount management not available"
+					}
+				};
+				const path = params.path;
+				if (!path) return {
+					id: req.id,
+					error: {
+						code: -32602,
+						message: "path is required"
+					}
+				};
+				await configManager.removeMount(path);
+				return {
+					id: req.id,
+					result: { success: true }
+				};
+			}
+			case "mount.update": {
+				if (!configManager) return {
+					id: req.id,
+					error: {
+						code: -32601,
+						message: "Mount management not available"
+					}
+				};
+				const path = params.path;
+				if (!path) return {
+					id: req.id,
+					error: {
+						code: -32602,
+						message: "path is required"
+					}
+				};
+				const { path: _path, ...updates } = params;
+				await configManager.updateMount(path, updates);
+				return {
+					id: req.id,
+					result: { success: true }
+				};
+			}
+			case "mount.test": {
+				if (!configManager) return {
+					id: req.id,
+					error: {
+						code: -32601,
+						message: "Mount management not available"
+					}
+				};
+				const uri = params.uri;
+				if (!uri) return {
+					id: req.id,
+					error: {
+						code: -32602,
+						message: "uri is required"
+					}
+				};
+				const result = await configManager.testMount(uri, params.auth);
+				return {
+					id: req.id,
+					result
+				};
+			}
+			case "config.get": {
+				if (!configManager) return {
+					id: req.id,
+					error: {
+						code: -32601,
+						message: "Mount management not available"
+					}
+				};
+				const config = await configManager.getConfig();
+				return {
+					id: req.id,
+					result: { config }
+				};
+			}
+			case "config.reload":
+				if (!configManager) return {
+					id: req.id,
+					error: {
+						code: -32601,
+						message: "Mount management not available"
+					}
+				};
+				await configManager.reloadConfig();
+				return {
+					id: req.id,
+					result: { success: true }
+				};
+			case "registry.list": {
+				if (!configManager?.getRegistry) return {
+					id: req.id,
+					error: {
+						code: -32601,
+						message: "Registry not available"
+					}
+				};
+				const providers = await configManager.getRegistry();
+				return {
+					id: req.id,
+					result: { providers }
+				};
+			}
+			default: return {
+				id: req.id,
+				error: {
+					code: -32601,
+					message: `Method not found: ${req.method}`
+				}
+			};
+		}
+	} catch (err) {
+		const message = err instanceof Error ? err.message : String(err);
+		return {
+			id: req.id,
+			error: {
+				code: -32e3,
+				message
+			}
+		};
+	}
+}
+
+//#endregion
+exports.ExplorerWSServer = ExplorerWSServer;

package/dist/ws-server.d.cts

@@ -0,0 +1,69 @@
+import { AFS } from "@aigne/afs";
+import { IncomingMessage, ServerResponse } from "node:http";
+
+//#region src/ws-server.d.ts
+/**
+ * ConfigManager interface for mount management operations.
+ * Implemented in CLI layer (knows config.toml path), injected into ws-server.
+ */
+interface ConfigManager {
+  getConfig(): Promise<unknown>;
+  getMountList(): Promise<{
+    mounts: unknown[];
+    failures: unknown[];
+  }>;
+  addMount(mount: Record<string, unknown>): Promise<void>;
+  removeMount(path: string): Promise<void>;
+  updateMount(path: string, updates: Record<string, unknown>): Promise<void>;
+  testMount(uri: string, auth?: string): Promise<{
+    success: boolean;
+    error?: string;
+    providerName?: string;
+  }>;
+  reloadConfig(): Promise<void>;
+  /** Get available providers from runtime discovery (scan installed @aigne/afs-* packages). */
+  getRegistry?(): Promise<Array<{
+    name: string;
+    description: string;
+    category: string;
+    uriTemplate: string;
+    tags?: string[];
+    packageName?: string;
+  }>>;
+}
+interface WSServerOptions {
+  port?: number;
+  host?: string;
+  /** Path to web/ directory for dev mode serving. */
+  webRoot?: string;
+  /** Embedded assets (for compiled binary mode). */
+  embeddedAssets?: Record<string, string>;
+  /** Open browser on start. */
+  open?: boolean;
+  /** Optional ConfigManager for mount management RPCs. */
+  configManager?: ConfigManager;
+  /**
+   * Optional HTTP middleware. Called before static file serving.
+   * Return true if the middleware handled the request.
+   */
+  httpMiddleware?: (req: IncomingMessage, res: ServerResponse) => Promise<boolean>;
+}
+declare class ExplorerWSServer {
+  private httpServer?;
+  private wss?;
+  private afs;
+  private options;
+  constructor(afs: AFS, options?: WSServerOptions);
+  /**
+   * Broadcast a JSON-RPC notification to all connected WebSocket clients.
+   */
+  broadcast(method: string, params?: Record<string, unknown>): void;
+  start(): Promise<{
+    port: number;
+    url: string;
+  }>;
+  stop(): void;
+}
+//#endregion
+export { ConfigManager, ExplorerWSServer, WSServerOptions };
+//# sourceMappingURL=ws-server.d.cts.map