@aigne/afs-cli 1.11.0-beta.1 → 1.11.0-beta.3

package/README.md

@@ -6,27 +6,81 @@ AFS 命令行工具
 
 | 命令 | 功能 |
 |------|------|
-| `afs ls [path]` | 列出目录内容 |
-| `afs cat <path>` | 读取文件内容 |
-| `afs write <path>` | 写入文件 |
-| `afs search <path> <pattern>` | 搜索内容 |
+| `afs list [path]` (别名: `ls`) | 列出目录内容 |
+| `afs read <path>` | 读取文件内容 |
+| `afs write <path> [--content]` | 写入文件 (--content 或 stdin) |
+| `afs stat <path>` | 获取文件/目录信息 |
 | `afs exec <path> <action>` | 执行操作 |
-| `afs explain <path>` | 语义解释 |
+| `afs mount list` (别名: `ls`) | 列出挂载配置 |
+| `afs mount add <path> <uri>` | 添加挂载 |
+| `afs mount remove <path>` (别名: `rm`) | 移除挂载 |
+| `afs mount validate` | 验证挂载配置 |
+| `afs explain [topic]` | 解释概念 (mount, uri, /path) |
+| `afs serve` | 启动 HTTP 服务器暴露 AFS 提供者 |
+
+## HTTP 服务器和远程挂载
+
+### 启动 AFS HTTP 服务器
+
+```bash
+# 启动服务器，暴露所有配置的挂载
+afs serve
+
+# 自定义主机和端口
+afs serve --host 0.0.0.0 --port 8080
+
+# 只读模式（禁用写入操作）
+afs serve --readonly
+
+# 启用 CORS 支持
+afs serve --cors
+
+# 自定义基础路径
+afs serve --path /api/afs
+```
+
+### 挂载远程 AFS 服务器
+
+```bash
+# 添加远程 HTTP 挂载
+afs mount add /remote http://localhost:3000/afs
+
+# 添加 HTTPS 挂载
+afs mount add /api https://api.example.com/afs
+
+# 带描述的挂载
+afs mount add /remote http://localhost:3000/afs --description "Remote AFS server"
+
+# 访问远程挂载
+afs list /remote
+afs read /remote/file.txt
+```
+
+### 支持的 URI 方案
+
+| 方案 | 示例 | 说明 |
+|------|------|------|
+| `fs://` | `fs:///path/to/dir` | 本地文件系统 |
+| `git://` | `git:///path/to/repo` | Git 仓库 |
+| `sqlite://` | `sqlite:///path/to/db.sqlite` | SQLite 数据库 |
+| `json://` | `json:///path/to/config.json` | JSON/YAML 文件 |
+| `http://` | `http://localhost:3000/afs` | HTTP 远程 AFS |
+| `https://` | `https://api.example.com/afs` | HTTPS 远程 AFS |
 
 ## 输出模式
 
 ```bash
 # 默认: Machine Truth (LLM/脚本友好)
-afs ls /modules/local-fs
+afs list /modules/fs
 
 # JSON 结构化输出
-afs ls /modules/local-fs --json
+afs list /modules/fs --json
 
 # LLM 优化输出
-afs ls /modules/local-fs --view=llm
+afs list /modules/fs --view=llm
 
 # 人类友好输出
-afs ls /modules/local-fs --view=human
+afs list /modules/fs --view=human
 ```
 
 ## 运行模式

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,29 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__toESM = __toESM;

package/dist/cli.cjs

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+const require_rolldown_runtime = require('./_virtual/rolldown_runtime.cjs');
+const require_version = require('./version.cjs');
+const require_exec = require('./commands/exec.cjs');
+const require_mount = require('./commands/mount.cjs');
+const require_explain = require('./commands/explain.cjs');
+const require_ls = require('./commands/ls.cjs');
+const require_read = require('./commands/read.cjs');
+const require_runtime = require('./runtime.cjs');
+const require_serve = require('./commands/serve.cjs');
+const require_stat = require('./commands/stat.cjs');
+const require_write = require('./commands/write.cjs');
+require('./commands/index.cjs');
+const require_errors = require('./errors.cjs');
+let yargs = require("yargs");
+yargs = require_rolldown_runtime.__toESM(yargs);
+let yargs_helpers = require("yargs/helpers");
+
+//#region src/cli.ts
+/**
+* AFS CLI - Command Line Interface
+*
+* Commands:
+* - afs mount list|ls          List mount configurations
+* - afs mount add <path> <uri> Add a mount
+* - afs mount remove|rm <path> Remove a mount
+* - afs mount validate         Validate mount configuration
+* - afs list|ls [path]         List directory
+* - afs stat <path>            Get file/directory info
+* - afs read <path>            Read file content
+* - afs write <path>           Write file content (--content or stdin)
+* - afs exec <path> <action>   Execute operation
+* - afs serve                  Start HTTP server to expose AFS
+*
+* Output modes:
+* - Default: Machine Truth (LLM/script friendly)
+* - --json: Structured JSON
+* - --view=llm: LLM optimized output
+* - --view=human: Human friendly format
+*/
+function getViewType(argv) {
+	if (argv.json) return "json";
+	if (argv.view) return argv.view;
+	return "default";
+}
+async function main() {
+	const cli = (0, yargs.default)((0, yargs_helpers.hideBin)(process.argv)).scriptName("afs").version(require_version.VERSION).alias("version", "V").help("help").alias("help", "h").usage("$0 <command> [options]").option("json", {
+		type: "boolean",
+		description: "Output in JSON format",
+		global: true
+	}).option("view", {
+		type: "string",
+		choices: [
+			"default",
+			"llm",
+			"human"
+		],
+		description: "Output view format",
+		global: true
+	}).command(["list [path]", "ls [path]"], "List directory contents", (yargs$2) => yargs$2.positional("path", {
+		type: "string",
+		default: "/",
+		description: "Path to list"
+	}).option("depth", {
+		type: "number",
+		default: 1,
+		description: "Maximum depth to list"
+	}).option("limit", {
+		alias: "n",
+		type: "number",
+		description: "Maximum number of entries to return"
+	}).option("max-children", {
+		type: "number",
+		description: "Maximum children per directory"
+	}).option("pattern", {
+		alias: "p",
+		type: "string",
+		description: "Glob pattern to filter entries (e.g., *.ts, **/*.js)"
+	}), async (argv) => {
+		const result = await require_ls.lsCommand(await require_runtime.createRuntime(), argv.path, {
+			maxDepth: argv.depth,
+			limit: argv.limit,
+			maxChildren: argv["max-children"],
+			pattern: argv.pattern
+		});
+		const view = getViewType(argv);
+		console.log(require_ls.formatLsOutput(result, view));
+	}).command("stat <path>", "Get file or directory info", (yargs$2) => yargs$2.positional("path", {
+		type: "string",
+		demandOption: true,
+		description: "Path to stat"
+	}), async (argv) => {
+		const result = await require_stat.statCommand(await require_runtime.createRuntime(), argv.path);
+		const view = getViewType(argv);
+		console.log(require_stat.formatStatOutput(result, view));
+	}).command("read <path>", "Read file content", (yargs$2) => yargs$2.positional("path", {
+		type: "string",
+		demandOption: true,
+		description: "Path to read"
+	}), async (argv) => {
+		const result = await require_read.readCommand(await require_runtime.createRuntime(), argv.path);
+		const view = getViewType(argv);
+		console.log(require_read.formatReadOutput(result, view));
+	}).command("write <path>", "Write content to file (from --content or stdin)", (yargs$2) => yargs$2.positional("path", {
+		type: "string",
+		demandOption: true,
+		description: "Path to write"
+	}).option("content", {
+		type: "string",
+		description: "Content to write (if not provided, reads from stdin)"
+	}).option("append", {
+		type: "boolean",
+		default: false,
+		description: "Append to file instead of overwrite"
+	}), async (argv) => {
+		let content;
+		if (argv.content !== void 0) content = argv.content;
+		else {
+			const chunks = [];
+			for await (const chunk of process.stdin) chunks.push(chunk);
+			content = Buffer.concat(chunks).toString("utf-8");
+		}
+		const result = await require_write.writeCommand(await require_runtime.createRuntime(), argv.path, content, { append: argv.append });
+		const view = getViewType(argv);
+		console.log(require_write.formatWriteOutput(result, view));
+		if (!result.success) process.exit(require_errors.ExitCode.RUNTIME_ERROR);
+	}).command("exec <path> [action]", "Execute operation on path", (yargs$2) => yargs$2.positional("path", {
+		type: "string",
+		demandOption: true,
+		description: "Path to execute on"
+	}).positional("action", {
+		type: "string",
+		default: "default",
+		description: "Action to execute"
+	}).option("params", {
+		type: "string",
+		description: "JSON parameters for the action"
+	}), async (argv) => {
+		const params = argv.params ? JSON.parse(argv.params) : {};
+		const result = await require_exec.execCommand(await require_runtime.createRuntime(), argv.path, argv.action, params);
+		const view = getViewType(argv);
+		console.log(require_exec.formatExecOutput(result, view));
+		if (!result.success) process.exit(require_errors.ExitCode.RUNTIME_ERROR);
+	}).command("mount", "Manage mount configurations", (yargs$2) => yargs$2.command(["list", "ls"], "List all mounts", () => {}, async (argv) => {
+		const result = await require_mount.mountListCommand(process.cwd());
+		const view = getViewType(argv);
+		console.log(require_mount.formatMountListOutput(result.mounts, view));
+	}).command("add <path> <uri>", "Add a new mount (path=virtual path, uri=data source)", (yargs$3) => yargs$3.positional("path", {
+		type: "string",
+		demandOption: true,
+		description: "Virtual path in AFS namespace (e.g., /src, /data)"
+	}).positional("uri", {
+		type: "string",
+		demandOption: true,
+		description: "Data source URI: fs:///local/path, git://repo, sqlite:///db.sqlite"
+	}).option("description", {
+		type: "string",
+		description: "Human-readable description for this mount"
+	}), async (argv) => {
+		const result = await require_mount.mountAddCommand(process.cwd(), argv.path, argv.uri, { description: argv.description });
+		if (getViewType(argv) === "json") console.log(JSON.stringify(result, null, 2));
+		else if (result.success) console.log(`Added mount ${argv.path}`);
+		else {
+			console.error(result.message);
+			process.exit(require_errors.ExitCode.RUNTIME_ERROR);
+		}
+	}).command(["remove <path>", "rm <path>"], "Remove a mount", (yargs$3) => yargs$3.positional("path", {
+		type: "string",
+		demandOption: true,
+		description: "Virtual path to remove (e.g., /src)"
+	}), async (argv) => {
+		const result = await require_mount.mountRemoveCommand(process.cwd(), argv.path);
+		if (getViewType(argv) === "json") console.log(JSON.stringify(result, null, 2));
+		else if (result.success) console.log(`Removed mount ${argv.path}`);
+		else {
+			console.error(result.message);
+			process.exit(require_errors.ExitCode.RUNTIME_ERROR);
+		}
+	}).command("validate", "Validate mount configuration", () => {}, async (argv) => {
+		const result = await require_mount.mountValidateCommand(process.cwd());
+		if (getViewType(argv) === "json") console.log(JSON.stringify(result, null, 2));
+		else if (result.valid) console.log("Configuration is valid");
+		else {
+			console.error("Configuration has errors:");
+			for (const error of result.errors) console.error(`  - ${error}`);
+			process.exit(require_errors.ExitCode.RUNTIME_ERROR);
+		}
+	}).demandCommand(1, "Please specify a mount subcommand"), () => {}).command("explain [topic]", "Explain AFS concepts or AFS object", (yargs$2) => yargs$2.positional("topic", {
+		type: "string",
+		description: "Topic (mount, path, uri) or AFS path (e.g., /modules/src)"
+	}), async (argv) => {
+		const view = getViewType(argv);
+		const topic = argv.topic;
+		if (topic?.startsWith("/")) {
+			const result = await require_explain.explainPathCommand(await require_runtime.createRuntime(), topic);
+			console.log(require_explain.formatPathExplainOutput(result, view));
+		} else {
+			const result = await require_explain.explainCommand(process.cwd(), topic);
+			console.log(require_explain.formatExplainOutput(result, view));
+		}
+	}).command("serve", "Start HTTP server to expose AFS providers", (yargs$2) => yargs$2.option("host", {
+		type: "string",
+		default: "localhost",
+		description: "Host address to listen on"
+	}).option("port", {
+		type: "number",
+		default: 3e3,
+		description: "Port to listen on"
+	}).option("path", {
+		type: "string",
+		default: "/afs",
+		description: "Base path for the server"
+	}).option("readonly", {
+		type: "boolean",
+		default: false,
+		description: "Run in readonly mode (disable write operations)"
+	}).option("cors", {
+		type: "boolean",
+		default: false,
+		description: "Enable CORS support"
+	}).option("max-body", {
+		type: "number",
+		description: "Maximum request body size in bytes (default: 10MB)"
+	}), async (argv) => {
+		const result = await require_serve.serveCommand({
+			host: argv.host,
+			port: argv.port,
+			path: argv.path,
+			readonly: argv.readonly,
+			cors: argv.cors,
+			maxBodySize: argv["max-body"]
+		});
+		console.log(require_serve.formatServeOutput(result));
+		await new Promise(() => {});
+	}).demandCommand(1, "Please specify a command").strict();
+	try {
+		await cli.parse();
+	} catch (error) {
+		if (error instanceof require_errors.CLIError) {
+			console.error(error.message);
+			process.exit(error.exitCode);
+		}
+		throw error;
+	}
+}
+main().catch((error) => {
+	console.error("Fatal error:", error.message);
+	process.exit(require_errors.ExitCode.RUNTIME_ERROR);
+});
+
+//#endregion

package/dist/cli.d.cts

@@ -0,0 +1 @@
+export { };

package/dist/cli.mjs

@@ -1,29 +1,251 @@
 #!/usr/bin/env node
-import { t as VERSION } from "./version--p6A8sKX.mjs";
+import { VERSION } from "./version.mjs";
+import { execCommand, formatExecOutput } from "./commands/exec.mjs";
+import { formatMountListOutput, mountAddCommand, mountListCommand, mountRemoveCommand, mountValidateCommand } from "./commands/mount.mjs";
+import { explainCommand, explainPathCommand, formatExplainOutput, formatPathExplainOutput } from "./commands/explain.mjs";
+import { formatLsOutput, lsCommand } from "./commands/ls.mjs";
+import { formatReadOutput, readCommand } from "./commands/read.mjs";
+import { createRuntime } from "./runtime.mjs";
+import { formatServeOutput, serveCommand } from "./commands/serve.mjs";
+import { formatStatOutput, statCommand } from "./commands/stat.mjs";
+import { formatWriteOutput, writeCommand } from "./commands/write.mjs";
+import "./commands/index.mjs";
+import { CLIError, ExitCode } from "./errors.mjs";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
 
 //#region src/cli.ts
 /**
 * AFS CLI - Command Line Interface
 *
-* 命令:
-* - afs ls [path]              列出目录
-* - afs cat <path>             读取文件
-* - afs write <path>           写入文件
-* - afs search <path> <pattern> 搜索内容
-* - afs exec <path> <action>   执行操作
-* - afs explain <path>         语义解释
+* Commands:
+* - afs mount list|ls          List mount configurations
+* - afs mount add <path> <uri> Add a mount
+* - afs mount remove|rm <path> Remove a mount
+* - afs mount validate         Validate mount configuration
+* - afs list|ls [path]         List directory
+* - afs stat <path>            Get file/directory info
+* - afs read <path>            Read file content
+* - afs write <path>           Write file content (--content or stdin)
+* - afs exec <path> <action>   Execute operation
+* - afs serve                  Start HTTP server to expose AFS
 *
-* 输出模式:
-* - 默认: Machine Truth (LLM/脚本友好)
-* - --json: 结构化 JSON
-* - --view=llm: LLM 优化输出
-* - --view=human: 人类友好格式
-*
-* 运行模式:
-* - 直接模式 (默认): 直接调用 @aigne/afs
-* - daemon 模式 (--daemon): 通过 afsd 代理
+* Output modes:
+* - Default: Machine Truth (LLM/script friendly)
+* - --json: Structured JSON
+* - --view=llm: LLM optimized output
+* - --view=human: Human friendly format
 */
-console.log(`afs-cli v${VERSION}`);
+function getViewType(argv) {
+	if (argv.json) return "json";
+	if (argv.view) return argv.view;
+	return "default";
+}
+async function main() {
+	const cli = yargs(hideBin(process.argv)).scriptName("afs").version(VERSION).alias("version", "V").help("help").alias("help", "h").usage("$0 <command> [options]").option("json", {
+		type: "boolean",
+		description: "Output in JSON format",
+		global: true
+	}).option("view", {
+		type: "string",
+		choices: [
+			"default",
+			"llm",
+			"human"
+		],
+		description: "Output view format",
+		global: true
+	}).command(["list [path]", "ls [path]"], "List directory contents", (yargs$1) => yargs$1.positional("path", {
+		type: "string",
+		default: "/",
+		description: "Path to list"
+	}).option("depth", {
+		type: "number",
+		default: 1,
+		description: "Maximum depth to list"
+	}).option("limit", {
+		alias: "n",
+		type: "number",
+		description: "Maximum number of entries to return"
+	}).option("max-children", {
+		type: "number",
+		description: "Maximum children per directory"
+	}).option("pattern", {
+		alias: "p",
+		type: "string",
+		description: "Glob pattern to filter entries (e.g., *.ts, **/*.js)"
+	}), async (argv) => {
+		const result = await lsCommand(await createRuntime(), argv.path, {
+			maxDepth: argv.depth,
+			limit: argv.limit,
+			maxChildren: argv["max-children"],
+			pattern: argv.pattern
+		});
+		const view = getViewType(argv);
+		console.log(formatLsOutput(result, view));
+	}).command("stat <path>", "Get file or directory info", (yargs$1) => yargs$1.positional("path", {
+		type: "string",
+		demandOption: true,
+		description: "Path to stat"
+	}), async (argv) => {
+		const result = await statCommand(await createRuntime(), argv.path);
+		const view = getViewType(argv);
+		console.log(formatStatOutput(result, view));
+	}).command("read <path>", "Read file content", (yargs$1) => yargs$1.positional("path", {
+		type: "string",
+		demandOption: true,
+		description: "Path to read"
+	}), async (argv) => {
+		const result = await readCommand(await createRuntime(), argv.path);
+		const view = getViewType(argv);
+		console.log(formatReadOutput(result, view));
+	}).command("write <path>", "Write content to file (from --content or stdin)", (yargs$1) => yargs$1.positional("path", {
+		type: "string",
+		demandOption: true,
+		description: "Path to write"
+	}).option("content", {
+		type: "string",
+		description: "Content to write (if not provided, reads from stdin)"
+	}).option("append", {
+		type: "boolean",
+		default: false,
+		description: "Append to file instead of overwrite"
+	}), async (argv) => {
+		let content;
+		if (argv.content !== void 0) content = argv.content;
+		else {
+			const chunks = [];
+			for await (const chunk of process.stdin) chunks.push(chunk);
+			content = Buffer.concat(chunks).toString("utf-8");
+		}
+		const result = await writeCommand(await createRuntime(), argv.path, content, { append: argv.append });
+		const view = getViewType(argv);
+		console.log(formatWriteOutput(result, view));
+		if (!result.success) process.exit(ExitCode.RUNTIME_ERROR);
+	}).command("exec <path> [action]", "Execute operation on path", (yargs$1) => yargs$1.positional("path", {
+		type: "string",
+		demandOption: true,
+		description: "Path to execute on"
+	}).positional("action", {
+		type: "string",
+		default: "default",
+		description: "Action to execute"
+	}).option("params", {
+		type: "string",
+		description: "JSON parameters for the action"
+	}), async (argv) => {
+		const params = argv.params ? JSON.parse(argv.params) : {};
+		const result = await execCommand(await createRuntime(), argv.path, argv.action, params);
+		const view = getViewType(argv);
+		console.log(formatExecOutput(result, view));
+		if (!result.success) process.exit(ExitCode.RUNTIME_ERROR);
+	}).command("mount", "Manage mount configurations", (yargs$1) => yargs$1.command(["list", "ls"], "List all mounts", () => {}, async (argv) => {
+		const result = await mountListCommand(process.cwd());
+		const view = getViewType(argv);
+		console.log(formatMountListOutput(result.mounts, view));
+	}).command("add <path> <uri>", "Add a new mount (path=virtual path, uri=data source)", (yargs$2) => yargs$2.positional("path", {
+		type: "string",
+		demandOption: true,
+		description: "Virtual path in AFS namespace (e.g., /src, /data)"
+	}).positional("uri", {
+		type: "string",
+		demandOption: true,
+		description: "Data source URI: fs:///local/path, git://repo, sqlite:///db.sqlite"
+	}).option("description", {
+		type: "string",
+		description: "Human-readable description for this mount"
+	}), async (argv) => {
+		const result = await mountAddCommand(process.cwd(), argv.path, argv.uri, { description: argv.description });
+		if (getViewType(argv) === "json") console.log(JSON.stringify(result, null, 2));
+		else if (result.success) console.log(`Added mount ${argv.path}`);
+		else {
+			console.error(result.message);
+			process.exit(ExitCode.RUNTIME_ERROR);
+		}
+	}).command(["remove <path>", "rm <path>"], "Remove a mount", (yargs$2) => yargs$2.positional("path", {
+		type: "string",
+		demandOption: true,
+		description: "Virtual path to remove (e.g., /src)"
+	}), async (argv) => {
+		const result = await mountRemoveCommand(process.cwd(), argv.path);
+		if (getViewType(argv) === "json") console.log(JSON.stringify(result, null, 2));
+		else if (result.success) console.log(`Removed mount ${argv.path}`);
+		else {
+			console.error(result.message);
+			process.exit(ExitCode.RUNTIME_ERROR);
+		}
+	}).command("validate", "Validate mount configuration", () => {}, async (argv) => {
+		const result = await mountValidateCommand(process.cwd());
+		if (getViewType(argv) === "json") console.log(JSON.stringify(result, null, 2));
+		else if (result.valid) console.log("Configuration is valid");
+		else {
+			console.error("Configuration has errors:");
+			for (const error of result.errors) console.error(`  - ${error}`);
+			process.exit(ExitCode.RUNTIME_ERROR);
+		}
+	}).demandCommand(1, "Please specify a mount subcommand"), () => {}).command("explain [topic]", "Explain AFS concepts or AFS object", (yargs$1) => yargs$1.positional("topic", {
+		type: "string",
+		description: "Topic (mount, path, uri) or AFS path (e.g., /modules/src)"
+	}), async (argv) => {
+		const view = getViewType(argv);
+		const topic = argv.topic;
+		if (topic?.startsWith("/")) {
+			const result = await explainPathCommand(await createRuntime(), topic);
+			console.log(formatPathExplainOutput(result, view));
+		} else {
+			const result = await explainCommand(process.cwd(), topic);
+			console.log(formatExplainOutput(result, view));
+		}
+	}).command("serve", "Start HTTP server to expose AFS providers", (yargs$1) => yargs$1.option("host", {
+		type: "string",
+		default: "localhost",
+		description: "Host address to listen on"
+	}).option("port", {
+		type: "number",
+		default: 3e3,
+		description: "Port to listen on"
+	}).option("path", {
+		type: "string",
+		default: "/afs",
+		description: "Base path for the server"
+	}).option("readonly", {
+		type: "boolean",
+		default: false,
+		description: "Run in readonly mode (disable write operations)"
+	}).option("cors", {
+		type: "boolean",
+		default: false,
+		description: "Enable CORS support"
+	}).option("max-body", {
+		type: "number",
+		description: "Maximum request body size in bytes (default: 10MB)"
+	}), async (argv) => {
+		const result = await serveCommand({
+			host: argv.host,
+			port: argv.port,
+			path: argv.path,
+			readonly: argv.readonly,
+			cors: argv.cors,
+			maxBodySize: argv["max-body"]
+		});
+		console.log(formatServeOutput(result));
+		await new Promise(() => {});
+	}).demandCommand(1, "Please specify a command").strict();
+	try {
+		await cli.parse();
+	} catch (error) {
+		if (error instanceof CLIError) {
+			console.error(error.message);
+			process.exit(error.exitCode);
+		}
+		throw error;
+	}
+}
+main().catch((error) => {
+	console.error("Fatal error:", error.message);
+	process.exit(ExitCode.RUNTIME_ERROR);
+});
 
 //#endregion
-export {  };
+export {  };
+//# sourceMappingURL=cli.mjs.map