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

package/dist/config/loader.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"loader.mjs","names":[],"sources":["../../src/config/loader.ts"],"sourcesContent":["import { access, readFile } from \"node:fs/promises\";\nimport { homedir } from \"node:os\";\nimport { dirname, join } from \"node:path\";\nimport { parse } from \"smol-toml\";\nimport { resolveEnvVarsInObject } from \"./env.js\";\nimport { type AFSConfig, ConfigSchema, type MountConfig, type ServeConfig } from \"./schema.js\";\n\nexport const CONFIG_DIR_NAME = \".afs-config\";\nexport const CONFIG_FILE_NAME = \"config.toml\";\n\nexport interface ConfigLoaderOptions {\n  /** Custom path to user-level config directory (for testing) */\n  userConfigDir?: string;\n}\n\nexport interface LoadWithSourcesResult {\n  config: AFSConfig;\n  /** Map from \"namespace:path\" → config directory that defines this mount */\n  mountSources: Map<string, string>;\n}\n\n/**\n * Environment variable to override user config directory.\n * Useful for testing to isolate from real user config.\n */\nexport const AFS_USER_CONFIG_DIR_ENV = \"AFS_USER_CONFIG_DIR\";\n\n/**\n * Loads and merges AFS configuration from multiple layers\n *\n * Layer priority (lowest to highest):\n * 1. User-level: ~/.afs-config/config.toml\n * 2. All intermediate directories from project root to cwd\n *\n * Example: if cwd is /project/packages/cli, configs are merged from:\n *   ~/.afs-config/config.toml (user)\n *   /project/.afs-config/config.toml (project root, has .git)\n *   /project/packages/.afs-config/config.toml (intermediate)\n *   /project/packages/cli/.afs-config/config.toml (cwd)\n */\nexport class ConfigLoader {\n  private userConfigDir: string;\n\n  constructor(options: ConfigLoaderOptions = {}) {\n    // Priority: options > environment variable > default (~/.afs-config)\n    this.userConfigDir =\n      options.userConfigDir ??\n      process.env[AFS_USER_CONFIG_DIR_ENV] ??\n      join(homedir(), CONFIG_DIR_NAME);\n  }\n\n  /**\n   * Load and merge configuration from all layers\n   *\n   * @param cwd - Current working directory (defaults to process.cwd())\n   * @returns Merged configuration\n   * @throws Error on invalid config, TOML parse error, or duplicate mount paths\n   */\n  async load(cwd: string = process.cwd()): Promise<AFSConfig> {\n    const result = await this.loadWithSources(cwd);\n    return result.config;\n  }\n\n  /**\n   * Load and merge configuration, also returning the config directory for each mount.\n   *\n   * mountSources maps \"namespace:path\" → config directory path (dirname of config file).\n   * Used by credential store to scope credentials per config location.\n   */\n  async loadWithSources(cwd: string = process.cwd()): Promise<LoadWithSourcesResult> {\n    const configPaths = await this.getConfigPaths(cwd);\n    const entries: { config: AFSConfig; configDir: string }[] = [];\n\n    for (const configPath of configPaths) {\n      const config = await this.loadSingleConfig(configPath);\n      entries.push({ config, configDir: dirname(configPath) });\n    }\n\n    return this.mergeConfigsWithSources(entries);\n  }\n\n  /**\n   * Get paths to all existing config files\n   *\n   * Collects configs from:\n   * 1. User-level: ~/.afs-config/config.toml\n   * 2. Project root (or topmost .afs-config dir) to cwd: all .afs-config/config.toml files\n   */\n  async getConfigPaths(cwd: string = process.cwd()): Promise<string[]> {\n    const paths: string[] = [];\n\n    // 1. User-level config\n    const userConfigPath = join(this.userConfigDir, CONFIG_FILE_NAME);\n    if (await this.fileExists(userConfigPath)) {\n      paths.push(userConfigPath);\n    }\n\n    // 2. Find project root (look for .git going up)\n    const projectRoot = await this.findProjectRoot(cwd);\n\n    // 3. Determine start directory\n    // If project root found, use it; otherwise find topmost .afs-config directory\n    const startDir = projectRoot ?? (await this.findTopmostAfsDir(cwd)) ?? cwd;\n\n    // 4. Collect all config files from start to cwd\n    // Exclude user config directory to avoid loading it twice\n    const intermediatePaths = await this.collectConfigsFromTo(startDir, cwd, this.userConfigDir);\n    paths.push(...intermediatePaths);\n\n    return paths;\n  }\n\n  /**\n   * Find the topmost directory containing .afs-config from startDir going up\n   */\n  private async findTopmostAfsDir(startDir: string): Promise<string | null> {\n    let currentDir = startDir;\n    let topmostAfsDir: string | null = null;\n\n    while (true) {\n      if (await this.fileExists(join(currentDir, CONFIG_DIR_NAME))) {\n        topmostAfsDir = currentDir;\n      }\n\n      const parentDir = dirname(currentDir);\n      if (parentDir === currentDir) {\n        // Reached filesystem root\n        break;\n      }\n      currentDir = parentDir;\n    }\n\n    return topmostAfsDir;\n  }\n\n  /**\n   * Collect all config files from startDir to endDir (inclusive)\n   * Returns paths in order from startDir to endDir (parent to child)\n   *\n   * @param excludeConfigDir - Optional config directory to exclude (to avoid duplicates)\n   */\n  private async collectConfigsFromTo(\n    startDir: string,\n    endDir: string,\n    excludeConfigDir?: string,\n  ): Promise<string[]> {\n    const paths: string[] = [];\n\n    // Build list of directories from startDir to endDir\n    const dirs: string[] = [];\n    let current = endDir;\n\n    while (true) {\n      dirs.unshift(current); // prepend to maintain parent-to-child order\n\n      if (current === startDir) {\n        break;\n      }\n\n      const parent = dirname(current);\n      if (parent === current) {\n        // Reached filesystem root without finding startDir\n        // This shouldn't happen if startDir is an ancestor of endDir\n        break;\n      }\n      current = parent;\n    }\n\n    // Check each directory for config file\n    for (const dir of dirs) {\n      const configDir = join(dir, CONFIG_DIR_NAME);\n      // Skip if this is the excluded config directory (e.g., user config already loaded)\n      if (excludeConfigDir && configDir === excludeConfigDir) {\n        continue;\n      }\n      const configPath = join(configDir, CONFIG_FILE_NAME);\n      if (await this.fileExists(configPath)) {\n        paths.push(configPath);\n      }\n    }\n\n    return paths;\n  }\n\n  /**\n   * Load a single config file\n   */\n  private async loadSingleConfig(configPath: string): Promise<AFSConfig> {\n    const content = await readFile(configPath, \"utf-8\");\n\n    let parsed: unknown;\n    try {\n      parsed = parse(content);\n    } catch (error) {\n      throw new Error(\n        `Failed to parse TOML config at ${configPath}: ${error instanceof Error ? error.message : String(error)}`,\n      );\n    }\n\n    // Resolve environment variables with friendly error messages\n    let resolved: unknown;\n    try {\n      resolved = resolveEnvVarsInObject(parsed);\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n      // Extract variable name from error message like \"Environment variable GITHUB_TOKEN is not defined\"\n      const match = message.match(/Environment variable (\\w+) is not defined/);\n      if (match) {\n        const varName = match[1];\n        throw new Error(\n          `Missing environment variable ${varName} in ${configPath}.\\n` +\n            `  Set it in your shell: export ${varName}=your_value\\n` +\n            `  Or add to .env file: ${varName}=your_value`,\n        );\n      }\n      throw new Error(`Failed to resolve environment variables in ${configPath}: ${message}`);\n    }\n\n    // Validate against schema\n    const result = ConfigSchema.safeParse(resolved);\n    if (!result.success) {\n      const errors = result.error.issues.map((e) => `${e.path.join(\".\")}: ${e.message}`).join(\"; \");\n      throw new Error(`Invalid config at ${configPath}: ${errors}`);\n    }\n\n    return result.data;\n  }\n\n  /**\n   * Create a composite key for namespace+path duplicate detection\n   * Uses empty string for undefined namespace (default namespace)\n   */\n  private makeNamespacePathKey(namespace: string | undefined, path: string): string {\n    return `${namespace ?? \"\"}:${path}`;\n  }\n\n  /**\n   * Merge configs with source tracking.\n   * Returns merged config plus a map of mount key → config directory.\n   */\n  private mergeConfigsWithSources(\n    entries: { config: AFSConfig; configDir: string }[],\n  ): LoadWithSourcesResult {\n    const mountIndexByKey = new Map<string, number>();\n    const allMounts: MountConfig[] = [];\n    const mountSources = new Map<string, string>();\n    let mergedServe: ServeConfig | undefined;\n\n    for (const { config, configDir } of entries) {\n      for (const mount of config.mounts) {\n        const key = this.makeNamespacePathKey(mount.namespace, mount.path);\n        const existingIndex = mountIndexByKey.get(key);\n        if (existingIndex !== undefined) {\n          allMounts[existingIndex] = mount;\n        } else {\n          mountIndexByKey.set(key, allMounts.length);\n          allMounts.push(mount);\n        }\n        // Track source (child overrides parent)\n        mountSources.set(key, configDir);\n      }\n\n      if (config.serve) {\n        mergedServe = mergedServe ? { ...mergedServe, ...config.serve } : config.serve;\n      }\n    }\n\n    return {\n      config: { mounts: allMounts, serve: mergedServe },\n      mountSources,\n    };\n  }\n\n  /**\n   * Find project root by looking for .git\n   * Note: Only .git is used as project root marker, not .afs-config,\n   * because .afs-config can exist at multiple levels for hierarchical config\n   */\n  async findProjectRoot(startDir: string): Promise<string | null> {\n    let currentDir = startDir;\n\n    while (true) {\n      // Check for .git directory\n      if (await this.fileExists(join(currentDir, \".git\"))) {\n        return currentDir;\n      }\n\n      const parentDir = dirname(currentDir);\n      if (parentDir === currentDir) {\n        // Reached filesystem root\n        return null;\n      }\n      currentDir = parentDir;\n    }\n  }\n\n  /**\n   * Check if a file or directory exists\n   */\n  private async fileExists(path: string): Promise<boolean> {\n    try {\n      await access(path);\n      return true;\n    } catch {\n      return false;\n    }\n  }\n}\n\n// Default singleton instance\nexport const configLoader = new ConfigLoader();\n"],"mappings":"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"}

package/dist/config/mount-commands.cjs

@@ -0,0 +1,226 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_schema = require('./schema.cjs');
+const require_loader = require('./loader.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_os = require("node:os");
+let node_path = require("node:path");
+let smol_toml = require("smol-toml");
+
+//#region src/config/mount-commands.ts
+/**
+* Mount Configuration Commands
+*
+* CLI-specific commands for managing mount configuration files.
+* These operate on afs.toml config files, not the AFS instance directly.
+*/
+/**
+* Check if a path looks like a remote Git URL
+*/
+function isRemoteGitUrl(path) {
+	if (/^[a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+:/.test(path)) return true;
+	if (/^(https?|ssh|git):\/\//.test(path)) return true;
+	return false;
+}
+/**
+* Resolve relative paths in URI to absolute paths
+*/
+function resolveUriPath(uri, cwd) {
+	const schemeMatch = uri.match(/^([a-z][a-z0-9+.-]*):\/\//i);
+	if (!schemeMatch) {
+		if (isRemoteGitUrl(uri)) return `git://${uri}`;
+		return `fs://${(0, node_path.isAbsolute)(uri) ? uri : (0, node_path.resolve)(cwd, uri)}`;
+	}
+	const scheme = schemeMatch[1];
+	const pathPart = uri.slice(schemeMatch[0].length);
+	if (![
+		"fs",
+		"git",
+		"sqlite",
+		"json"
+	].includes(scheme)) return uri;
+	if (scheme === "git" && isRemoteGitUrl(pathPart)) return uri;
+	if ((0, node_path.isAbsolute)(pathPart)) return uri;
+	return `${scheme}://${(0, node_path.resolve)(cwd, pathPart)}`;
+}
+/**
+* List all mounts from config (merged from all config layers)
+*/
+async function configMountListCommand(cwd) {
+	return { mounts: (await new require_loader.ConfigLoader().load(cwd)).mounts };
+}
+/**
+* Remove a mount from config
+*/
+async function mountRemoveCommand(cwd, path) {
+	const configPath = (0, node_path.join)(cwd, require_loader.CONFIG_DIR_NAME, require_loader.CONFIG_FILE_NAME);
+	try {
+		const config = (0, smol_toml.parse)(await (0, node_fs_promises.readFile)(configPath, "utf-8"));
+		const mounts = config.mounts ?? [];
+		const index = mounts.findIndex((m) => m.path === path);
+		if (index === -1) return {
+			success: false,
+			message: `Mount path "${path}" not found`
+		};
+		mounts.splice(index, 1);
+		config.mounts = mounts;
+		await (0, node_fs_promises.writeFile)(configPath, (0, smol_toml.stringify)(config), "utf-8");
+		return { success: true };
+	} catch {
+		return {
+			success: false,
+			message: `Mount path "${path}" not found`
+		};
+	}
+}
+/**
+* Resolve a PersistScope to the config directory path.
+*
+* - "cwd"     → <cwd>/.afs-config/
+* - "project" → <projectRoot>/.afs-config/ (falls back to cwd if no .git found)
+* - "user"    → ~/.afs-config/
+*/
+async function resolveScopeDir(cwd, scope) {
+	if (scope === "user") return (0, node_path.join)((0, node_os.homedir)(), require_loader.CONFIG_DIR_NAME);
+	if (scope === "project") {
+		const projectRoot = await new require_loader.ConfigLoader().findProjectRoot(cwd);
+		if (projectRoot) return (0, node_path.join)(projectRoot, require_loader.CONFIG_DIR_NAME);
+		return (0, node_path.join)(cwd, require_loader.CONFIG_DIR_NAME);
+	}
+	return (0, node_path.join)(cwd, require_loader.CONFIG_DIR_NAME);
+}
+/**
+* Persist a mount entry to config.toml at the given scope.
+*
+* Uses upsert semantics: if a mount with the same path already exists,
+* it is replaced. Otherwise the new entry is appended.
+*/
+async function persistMount(cwd, entry, scope = "cwd") {
+	const configDir = await resolveScopeDir(cwd, scope);
+	const configPath = (0, node_path.join)(configDir, require_loader.CONFIG_FILE_NAME);
+	const config = { mounts: [] };
+	try {
+		const parsed = (0, smol_toml.parse)(await (0, node_fs_promises.readFile)(configPath, "utf-8"));
+		config.mounts = parsed.mounts ?? [];
+		for (const key of Object.keys(parsed)) if (key !== "mounts") config[key] = parsed[key];
+	} catch {}
+	const existingIndex = config.mounts.findIndex((m) => m.path === entry.path);
+	if (existingIndex >= 0) config.mounts[existingIndex] = entry;
+	else config.mounts.push(entry);
+	try {
+		await (0, node_fs_promises.mkdir)(configDir, { recursive: true });
+	} catch {}
+	await (0, node_fs_promises.writeFile)(configPath, (0, smol_toml.stringify)(config), "utf-8");
+	return {
+		success: true,
+		configPath
+	};
+}
+/**
+* Update specific options on an existing mount entry in a config file.
+*
+* Merges `optionUpdates` into the mount's `options` field (shallow merge).
+* If the mount is not found in the given configDir, this is a no-op.
+*/
+async function updateMountOptions(configDir, mountPath, optionUpdates) {
+	const configPath = (0, node_path.join)(configDir, require_loader.CONFIG_FILE_NAME);
+	const parsed = (0, smol_toml.parse)(await (0, node_fs_promises.readFile)(configPath, "utf-8"));
+	const entry = (parsed.mounts ?? []).find((m) => m.path === mountPath);
+	if (!entry) return;
+	entry.options = {
+		...entry.options,
+		...optionUpdates
+	};
+	await (0, node_fs_promises.writeFile)(configPath, (0, smol_toml.stringify)(parsed), "utf-8");
+}
+/**
+* Remove a mount entry from config.toml.
+*
+* If `scope` is provided, only searches the specific config file for that scope.
+* If `scope` is undefined, searches all config files (cwd, project, user) and
+* removes from the first one that contains the mount path.
+*/
+async function unpersistMount(cwd, mountPath, scope) {
+	if (scope) return removeFromConfigFile(cwd, mountPath, scope);
+	for (const s of [
+		"cwd",
+		"project",
+		"user"
+	]) {
+		const result = await removeFromConfigFile(cwd, mountPath, s);
+		if (result.success) return result;
+	}
+	return {
+		success: false,
+		message: `Mount path "${mountPath}" not found in any config`
+	};
+}
+/**
+* Remove a mount from a specific config file.
+*/
+async function removeFromConfigFile(cwd, mountPath, scope) {
+	const configPath = (0, node_path.join)(await resolveScopeDir(cwd, scope), require_loader.CONFIG_FILE_NAME);
+	try {
+		const parsed = (0, smol_toml.parse)(await (0, node_fs_promises.readFile)(configPath, "utf-8"));
+		const mounts = parsed.mounts ?? [];
+		const index = mounts.findIndex((m) => m.path === mountPath);
+		if (index === -1) return {
+			success: false,
+			message: `Mount path "${mountPath}" not found in ${configPath}`
+		};
+		mounts.splice(index, 1);
+		parsed.mounts = mounts;
+		await (0, node_fs_promises.writeFile)(configPath, (0, smol_toml.stringify)(parsed), "utf-8");
+		return {
+			success: true,
+			configPath
+		};
+	} catch {
+		return {
+			success: false,
+			message: `Config file not found or unreadable: ${configPath}`
+		};
+	}
+}
+/**
+* Validate mount configuration
+*/
+async function mountValidateCommand(cwd) {
+	const configPath = (0, node_path.join)(cwd, require_loader.CONFIG_DIR_NAME, require_loader.CONFIG_FILE_NAME);
+	const errors = [];
+	try {
+		const mounts = (0, smol_toml.parse)(await (0, node_fs_promises.readFile)(configPath, "utf-8")).mounts ?? [];
+		for (const mount of mounts) {
+			const validation = require_schema.MountSchema.safeParse(mount);
+			if (!validation.success) {
+				for (const err of validation.error.issues) errors.push(`Mount "${mount.path}": ${err.message}`);
+				continue;
+			}
+			if (mount.uri.startsWith("fs://")) {
+				const targetPath = mount.uri.replace("fs://", "");
+				try {
+					await (0, node_fs_promises.access)(targetPath);
+				} catch {
+					errors.push(`Mount target "${targetPath}" does not exist`);
+				}
+			}
+		}
+		return {
+			valid: errors.length === 0,
+			errors
+		};
+	} catch {
+		return {
+			valid: true,
+			errors: []
+		};
+	}
+}
+
+//#endregion
+exports.configMountListCommand = configMountListCommand;
+exports.mountRemoveCommand = mountRemoveCommand;
+exports.mountValidateCommand = mountValidateCommand;
+exports.persistMount = persistMount;
+exports.resolveUriPath = resolveUriPath;
+exports.unpersistMount = unpersistMount;
+exports.updateMountOptions = updateMountOptions;

package/dist/config/mount-commands.d.cts

@@ -0,0 +1,14 @@
+//#region src/config/mount-commands.d.ts
+interface ConfigMountEntry {
+  path: string;
+  uri: string;
+  namespace?: string;
+  description?: string;
+  access_mode?: "readonly" | "readwrite";
+  auth?: string;
+  token?: string;
+  options?: Record<string, unknown>;
+}
+//#endregion
+export { ConfigMountEntry };
+//# sourceMappingURL=mount-commands.d.cts.map

package/dist/config/mount-commands.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mount-commands.d.cts","names":[],"sources":["../../src/config/mount-commands.ts"],"mappings":";UAwBiB,gBAAA;EACf,IAAA;EACA,GAAA;EACA,SAAA;EACA,WAAA;EACA,WAAA;EACA,IAAA;EACA,KAAA;EACA,OAAA,GAAU,MAAA;AAAA"}

package/dist/config/mount-commands.d.mts

@@ -0,0 +1,14 @@
+//#region src/config/mount-commands.d.ts
+interface ConfigMountEntry {
+  path: string;
+  uri: string;
+  namespace?: string;
+  description?: string;
+  access_mode?: "readonly" | "readwrite";
+  auth?: string;
+  token?: string;
+  options?: Record<string, unknown>;
+}
+//#endregion
+export { ConfigMountEntry };
+//# sourceMappingURL=mount-commands.d.mts.map

package/dist/config/mount-commands.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mount-commands.d.mts","names":[],"sources":["../../src/config/mount-commands.ts"],"mappings":";UAwBiB,gBAAA;EACf,IAAA;EACA,GAAA;EACA,SAAA;EACA,WAAA;EACA,WAAA;EACA,IAAA;EACA,KAAA;EACA,OAAA,GAAU,MAAA;AAAA"}

package/dist/config/mount-commands.mjs

@@ -0,0 +1,220 @@
+import { MountSchema } from "./schema.mjs";
+import { CONFIG_DIR_NAME, CONFIG_FILE_NAME, ConfigLoader } from "./loader.mjs";
+import { access, mkdir, readFile, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+import { parse, stringify } from "smol-toml";
+
+//#region src/config/mount-commands.ts
+/**
+* Mount Configuration Commands
+*
+* CLI-specific commands for managing mount configuration files.
+* These operate on afs.toml config files, not the AFS instance directly.
+*/
+/**
+* Check if a path looks like a remote Git URL
+*/
+function isRemoteGitUrl(path) {
+	if (/^[a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+:/.test(path)) return true;
+	if (/^(https?|ssh|git):\/\//.test(path)) return true;
+	return false;
+}
+/**
+* Resolve relative paths in URI to absolute paths
+*/
+function resolveUriPath(uri, cwd) {
+	const schemeMatch = uri.match(/^([a-z][a-z0-9+.-]*):\/\//i);
+	if (!schemeMatch) {
+		if (isRemoteGitUrl(uri)) return `git://${uri}`;
+		return `fs://${isAbsolute(uri) ? uri : resolve(cwd, uri)}`;
+	}
+	const scheme = schemeMatch[1];
+	const pathPart = uri.slice(schemeMatch[0].length);
+	if (![
+		"fs",
+		"git",
+		"sqlite",
+		"json"
+	].includes(scheme)) return uri;
+	if (scheme === "git" && isRemoteGitUrl(pathPart)) return uri;
+	if (isAbsolute(pathPart)) return uri;
+	return `${scheme}://${resolve(cwd, pathPart)}`;
+}
+/**
+* List all mounts from config (merged from all config layers)
+*/
+async function configMountListCommand(cwd) {
+	return { mounts: (await new ConfigLoader().load(cwd)).mounts };
+}
+/**
+* Remove a mount from config
+*/
+async function mountRemoveCommand(cwd, path) {
+	const configPath = join(cwd, CONFIG_DIR_NAME, CONFIG_FILE_NAME);
+	try {
+		const config = parse(await readFile(configPath, "utf-8"));
+		const mounts = config.mounts ?? [];
+		const index = mounts.findIndex((m) => m.path === path);
+		if (index === -1) return {
+			success: false,
+			message: `Mount path "${path}" not found`
+		};
+		mounts.splice(index, 1);
+		config.mounts = mounts;
+		await writeFile(configPath, stringify(config), "utf-8");
+		return { success: true };
+	} catch {
+		return {
+			success: false,
+			message: `Mount path "${path}" not found`
+		};
+	}
+}
+/**
+* Resolve a PersistScope to the config directory path.
+*
+* - "cwd"     → <cwd>/.afs-config/
+* - "project" → <projectRoot>/.afs-config/ (falls back to cwd if no .git found)
+* - "user"    → ~/.afs-config/
+*/
+async function resolveScopeDir(cwd, scope) {
+	if (scope === "user") return join(homedir(), CONFIG_DIR_NAME);
+	if (scope === "project") {
+		const projectRoot = await new ConfigLoader().findProjectRoot(cwd);
+		if (projectRoot) return join(projectRoot, CONFIG_DIR_NAME);
+		return join(cwd, CONFIG_DIR_NAME);
+	}
+	return join(cwd, CONFIG_DIR_NAME);
+}
+/**
+* Persist a mount entry to config.toml at the given scope.
+*
+* Uses upsert semantics: if a mount with the same path already exists,
+* it is replaced. Otherwise the new entry is appended.
+*/
+async function persistMount(cwd, entry, scope = "cwd") {
+	const configDir = await resolveScopeDir(cwd, scope);
+	const configPath = join(configDir, CONFIG_FILE_NAME);
+	const config = { mounts: [] };
+	try {
+		const parsed = parse(await readFile(configPath, "utf-8"));
+		config.mounts = parsed.mounts ?? [];
+		for (const key of Object.keys(parsed)) if (key !== "mounts") config[key] = parsed[key];
+	} catch {}
+	const existingIndex = config.mounts.findIndex((m) => m.path === entry.path);
+	if (existingIndex >= 0) config.mounts[existingIndex] = entry;
+	else config.mounts.push(entry);
+	try {
+		await mkdir(configDir, { recursive: true });
+	} catch {}
+	await writeFile(configPath, stringify(config), "utf-8");
+	return {
+		success: true,
+		configPath
+	};
+}
+/**
+* Update specific options on an existing mount entry in a config file.
+*
+* Merges `optionUpdates` into the mount's `options` field (shallow merge).
+* If the mount is not found in the given configDir, this is a no-op.
+*/
+async function updateMountOptions(configDir, mountPath, optionUpdates) {
+	const configPath = join(configDir, CONFIG_FILE_NAME);
+	const parsed = parse(await readFile(configPath, "utf-8"));
+	const entry = (parsed.mounts ?? []).find((m) => m.path === mountPath);
+	if (!entry) return;
+	entry.options = {
+		...entry.options,
+		...optionUpdates
+	};
+	await writeFile(configPath, stringify(parsed), "utf-8");
+}
+/**
+* Remove a mount entry from config.toml.
+*
+* If `scope` is provided, only searches the specific config file for that scope.
+* If `scope` is undefined, searches all config files (cwd, project, user) and
+* removes from the first one that contains the mount path.
+*/
+async function unpersistMount(cwd, mountPath, scope) {
+	if (scope) return removeFromConfigFile(cwd, mountPath, scope);
+	for (const s of [
+		"cwd",
+		"project",
+		"user"
+	]) {
+		const result = await removeFromConfigFile(cwd, mountPath, s);
+		if (result.success) return result;
+	}
+	return {
+		success: false,
+		message: `Mount path "${mountPath}" not found in any config`
+	};
+}
+/**
+* Remove a mount from a specific config file.
+*/
+async function removeFromConfigFile(cwd, mountPath, scope) {
+	const configPath = join(await resolveScopeDir(cwd, scope), CONFIG_FILE_NAME);
+	try {
+		const parsed = parse(await readFile(configPath, "utf-8"));
+		const mounts = parsed.mounts ?? [];
+		const index = mounts.findIndex((m) => m.path === mountPath);
+		if (index === -1) return {
+			success: false,
+			message: `Mount path "${mountPath}" not found in ${configPath}`
+		};
+		mounts.splice(index, 1);
+		parsed.mounts = mounts;
+		await writeFile(configPath, stringify(parsed), "utf-8");
+		return {
+			success: true,
+			configPath
+		};
+	} catch {
+		return {
+			success: false,
+			message: `Config file not found or unreadable: ${configPath}`
+		};
+	}
+}
+/**
+* Validate mount configuration
+*/
+async function mountValidateCommand(cwd) {
+	const configPath = join(cwd, CONFIG_DIR_NAME, CONFIG_FILE_NAME);
+	const errors = [];
+	try {
+		const mounts = parse(await readFile(configPath, "utf-8")).mounts ?? [];
+		for (const mount of mounts) {
+			const validation = MountSchema.safeParse(mount);
+			if (!validation.success) {
+				for (const err of validation.error.issues) errors.push(`Mount "${mount.path}": ${err.message}`);
+				continue;
+			}
+			if (mount.uri.startsWith("fs://")) {
+				const targetPath = mount.uri.replace("fs://", "");
+				try {
+					await access(targetPath);
+				} catch {
+					errors.push(`Mount target "${targetPath}" does not exist`);
+				}
+			}
+		}
+		return {
+			valid: errors.length === 0,
+			errors
+		};
+	} catch {
+		return {
+			valid: true,
+			errors: []
+		};
+	}
+}
+
+//#endregion
+export { configMountListCommand, mountRemoveCommand, mountValidateCommand, persistMount, resolveUriPath, unpersistMount, updateMountOptions };
+//# sourceMappingURL=mount-commands.mjs.map

package/dist/config/mount-commands.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"mount-commands.mjs","names":[],"sources":["../../src/config/mount-commands.ts"],"sourcesContent":["/**\n * Mount Configuration Commands\n *\n * CLI-specific commands for managing mount configuration files.\n * These operate on afs.toml config files, not the AFS instance directly.\n */\n\nimport { access, mkdir, readFile, writeFile } from \"node:fs/promises\";\nimport { homedir } from \"node:os\";\nimport { isAbsolute, join, resolve } from \"node:path\";\nimport { parse, stringify } from \"smol-toml\";\nimport { CONFIG_DIR_NAME, CONFIG_FILE_NAME, ConfigLoader } from \"./loader.js\";\nimport { MountSchema } from \"./schema.js\";\n\n// ─── Persistence Types ───────────────────────────────────────────────────\n\nexport type PersistScope = \"cwd\" | \"project\" | \"user\";\n\nexport interface PersistResult {\n  success: boolean;\n  configPath?: string;\n  message?: string;\n}\n\nexport interface ConfigMountEntry {\n  path: string;\n  uri: string;\n  namespace?: string;\n  description?: string;\n  access_mode?: \"readonly\" | \"readwrite\";\n  auth?: string;\n  token?: string;\n  options?: Record<string, unknown>;\n}\n\nexport interface ConfigMountListResult {\n  mounts: ConfigMountEntry[];\n}\n\nexport interface MountCommandResult {\n  success: boolean;\n  message?: string;\n  normalizedPath?: string;\n}\n\nexport interface MountValidateResult {\n  valid: boolean;\n  errors: string[];\n}\n\n/**\n * Check if a path looks like a remote Git URL\n */\nfunction isRemoteGitUrl(path: string): boolean {\n  if (/^[a-zA-Z0-9._-]+@[a-zA-Z0-9._-]+:/.test(path)) {\n    return true;\n  }\n  if (/^(https?|ssh|git):\\/\\//.test(path)) {\n    return true;\n  }\n  return false;\n}\n\n/**\n * Resolve relative paths in URI to absolute paths\n */\nexport function resolveUriPath(uri: string, cwd: string): string {\n  const schemeMatch = uri.match(/^([a-z][a-z0-9+.-]*):\\/\\//i);\n\n  if (!schemeMatch) {\n    if (isRemoteGitUrl(uri)) {\n      return `git://${uri}`;\n    }\n    const absolutePath = isAbsolute(uri) ? uri : resolve(cwd, uri);\n    return `fs://${absolutePath}`;\n  }\n\n  const scheme = schemeMatch[1];\n  const pathPart = uri.slice(schemeMatch[0].length);\n\n  if (![\"fs\", \"git\", \"sqlite\", \"json\"].includes(scheme!)) {\n    return uri;\n  }\n\n  if (scheme === \"git\" && isRemoteGitUrl(pathPart)) {\n    return uri;\n  }\n\n  if (isAbsolute(pathPart)) {\n    return uri;\n  }\n\n  const absolutePath = resolve(cwd, pathPart);\n  return `${scheme}://${absolutePath}`;\n}\n\n/**\n * List all mounts from config (merged from all config layers)\n */\nexport async function configMountListCommand(cwd: string): Promise<ConfigMountListResult> {\n  const loader = new ConfigLoader();\n  const config = await loader.load(cwd);\n  return {\n    mounts: config.mounts as ConfigMountEntry[],\n  };\n}\n\n/**\n * Add a mount to config\n */\nexport async function mountAddCommand(\n  cwd: string,\n  path: string,\n  uri: string,\n  options: { description?: string; token?: string } = {},\n): Promise<MountCommandResult> {\n  if (!uri || uri.trim() === \"\") {\n    return {\n      success: false,\n      message: \"URI is required\",\n    };\n  }\n\n  const resolvedUri = resolveUriPath(uri, cwd);\n\n  const validation = MountSchema.safeParse({\n    path,\n    uri: resolvedUri,\n    ...options,\n  });\n  if (!validation.success) {\n    const errors = validation.error.issues.map((e) => e.message).join(\"; \");\n    return {\n      success: false,\n      message: errors,\n    };\n  }\n\n  const newMount: ConfigMountEntry = {\n    path: validation.data.path,\n    uri: validation.data.uri,\n    ...(options.description && { description: options.description }),\n    ...(options.token && { token: options.token }),\n  };\n\n  const configDir = join(cwd, CONFIG_DIR_NAME);\n  const configPath = join(configDir, CONFIG_FILE_NAME);\n\n  const config: { mounts: ConfigMountEntry[] } = { mounts: [] };\n\n  try {\n    const content = await readFile(configPath, \"utf-8\");\n    const parsed = parse(content) as { mounts?: ConfigMountEntry[] };\n    config.mounts = parsed.mounts ?? [];\n  } catch {\n    // Config doesn't exist, will create\n  }\n\n  const normalizedPath = validation.data.path;\n  if (config.mounts.some((m) => m.path === normalizedPath)) {\n    return {\n      success: false,\n      message: `Mount path \"${normalizedPath}\" already exists`,\n    };\n  }\n\n  config.mounts.push(newMount);\n\n  try {\n    await mkdir(configDir, { recursive: true });\n  } catch {\n    // Directory might already exist\n  }\n\n  await writeFile(configPath, stringify(config), \"utf-8\");\n\n  return {\n    success: true,\n    normalizedPath,\n  };\n}\n\n/**\n * Remove a mount from config\n */\nexport async function mountRemoveCommand(cwd: string, path: string): Promise<MountCommandResult> {\n  const configPath = join(cwd, CONFIG_DIR_NAME, CONFIG_FILE_NAME);\n\n  try {\n    const content = await readFile(configPath, \"utf-8\");\n    const config = parse(content) as { mounts?: ConfigMountEntry[] };\n    const mounts = config.mounts ?? [];\n\n    const index = mounts.findIndex((m) => m.path === path);\n    if (index === -1) {\n      return {\n        success: false,\n        message: `Mount path \"${path}\" not found`,\n      };\n    }\n\n    mounts.splice(index, 1);\n    config.mounts = mounts;\n\n    await writeFile(configPath, stringify(config), \"utf-8\");\n\n    return {\n      success: true,\n    };\n  } catch {\n    return {\n      success: false,\n      message: `Mount path \"${path}\" not found`,\n    };\n  }\n}\n\n// ─── Persistence Functions ────────────────────────────────────────────────\n\n/**\n * Resolve a PersistScope to the config directory path.\n *\n * - \"cwd\"     → <cwd>/.afs-config/\n * - \"project\" → <projectRoot>/.afs-config/ (falls back to cwd if no .git found)\n * - \"user\"    → ~/.afs-config/\n */\nexport async function resolveScopeDir(cwd: string, scope: PersistScope): Promise<string> {\n  if (scope === \"user\") {\n    return join(homedir(), CONFIG_DIR_NAME);\n  }\n\n  if (scope === \"project\") {\n    const loader = new ConfigLoader();\n    const projectRoot = await loader.findProjectRoot(cwd);\n    if (projectRoot) {\n      return join(projectRoot, CONFIG_DIR_NAME);\n    }\n    // Fall back to cwd when no .git found\n    return join(cwd, CONFIG_DIR_NAME);\n  }\n\n  // \"cwd\"\n  return join(cwd, CONFIG_DIR_NAME);\n}\n\n/**\n * Persist a mount entry to config.toml at the given scope.\n *\n * Uses upsert semantics: if a mount with the same path already exists,\n * it is replaced. Otherwise the new entry is appended.\n */\nexport async function persistMount(\n  cwd: string,\n  entry: ConfigMountEntry,\n  scope: PersistScope = \"cwd\",\n): Promise<PersistResult> {\n  const configDir = await resolveScopeDir(cwd, scope);\n  const configPath = join(configDir, CONFIG_FILE_NAME);\n\n  // Read existing config (or start empty)\n  const config: Record<string, unknown> & { mounts: ConfigMountEntry[] } = { mounts: [] };\n  try {\n    const content = await readFile(configPath, \"utf-8\");\n    const parsed = parse(content) as Record<string, unknown>;\n    config.mounts = (parsed.mounts as ConfigMountEntry[] | undefined) ?? [];\n    // Preserve non-mount sections (serve, registry, etc.)\n    for (const key of Object.keys(parsed)) {\n      if (key !== \"mounts\") {\n        config[key] = parsed[key];\n      }\n    }\n  } catch {\n    // Config doesn't exist yet, will create\n  }\n\n  // Upsert: replace existing entry at same path, or append\n  const existingIndex = config.mounts.findIndex((m) => m.path === entry.path);\n  if (existingIndex >= 0) {\n    config.mounts[existingIndex] = entry;\n  } else {\n    config.mounts.push(entry);\n  }\n\n  // Write back\n  try {\n    await mkdir(configDir, { recursive: true });\n  } catch {\n    // Directory might already exist\n  }\n\n  await writeFile(configPath, stringify(config), \"utf-8\");\n\n  return { success: true, configPath };\n}\n\n/**\n * Update specific options on an existing mount entry in a config file.\n *\n * Merges `optionUpdates` into the mount's `options` field (shallow merge).\n * If the mount is not found in the given configDir, this is a no-op.\n */\nexport async function updateMountOptions(\n  configDir: string,\n  mountPath: string,\n  optionUpdates: Record<string, unknown>,\n): Promise<void> {\n  const configPath = join(configDir, CONFIG_FILE_NAME);\n  const content = await readFile(configPath, \"utf-8\");\n  const parsed = parse(content) as Record<string, unknown>;\n  const mounts = (parsed.mounts as ConfigMountEntry[]) ?? [];\n  const entry = mounts.find((m) => m.path === mountPath);\n  if (!entry) return;\n  entry.options = { ...entry.options, ...optionUpdates };\n  await writeFile(configPath, stringify(parsed as Record<string, unknown>), \"utf-8\");\n}\n\n/**\n * Remove a mount entry from config.toml.\n *\n * If `scope` is provided, only searches the specific config file for that scope.\n * If `scope` is undefined, searches all config files (cwd, project, user) and\n * removes from the first one that contains the mount path.\n */\nexport async function unpersistMount(\n  cwd: string,\n  mountPath: string,\n  scope?: PersistScope,\n): Promise<PersistResult> {\n  if (scope) {\n    return removeFromConfigFile(cwd, mountPath, scope);\n  }\n\n  // Search all scopes: cwd → project → user\n  for (const s of [\"cwd\", \"project\", \"user\"] as PersistScope[]) {\n    const result = await removeFromConfigFile(cwd, mountPath, s);\n    if (result.success) return result;\n  }\n\n  return { success: false, message: `Mount path \"${mountPath}\" not found in any config` };\n}\n\n/**\n * Remove a mount from a specific config file.\n */\nasync function removeFromConfigFile(\n  cwd: string,\n  mountPath: string,\n  scope: PersistScope,\n): Promise<PersistResult> {\n  const configDir = await resolveScopeDir(cwd, scope);\n  const configPath = join(configDir, CONFIG_FILE_NAME);\n\n  try {\n    const content = await readFile(configPath, \"utf-8\");\n    const parsed = parse(content) as Record<string, unknown>;\n    const mounts = (parsed.mounts as ConfigMountEntry[] | undefined) ?? [];\n\n    const index = mounts.findIndex((m) => m.path === mountPath);\n    if (index === -1) {\n      return { success: false, message: `Mount path \"${mountPath}\" not found in ${configPath}` };\n    }\n\n    mounts.splice(index, 1);\n    parsed.mounts = mounts;\n\n    await writeFile(configPath, stringify(parsed), \"utf-8\");\n\n    return { success: true, configPath };\n  } catch {\n    return { success: false, message: `Config file not found or unreadable: ${configPath}` };\n  }\n}\n\n/**\n * Validate mount configuration\n */\nexport async function mountValidateCommand(cwd: string): Promise<MountValidateResult> {\n  const configPath = join(cwd, CONFIG_DIR_NAME, CONFIG_FILE_NAME);\n  const errors: string[] = [];\n\n  try {\n    const content = await readFile(configPath, \"utf-8\");\n    const config = parse(content) as { mounts?: ConfigMountEntry[] };\n    const mounts = config.mounts ?? [];\n\n    for (const mount of mounts) {\n      const validation = MountSchema.safeParse(mount);\n      if (!validation.success) {\n        for (const err of validation.error.issues) {\n          errors.push(`Mount \"${mount.path}\": ${err.message}`);\n        }\n        continue;\n      }\n\n      if (mount.uri.startsWith(\"fs://\")) {\n        const targetPath = mount.uri.replace(\"fs://\", \"\");\n        try {\n          await access(targetPath);\n        } catch {\n          errors.push(`Mount target \"${targetPath}\" does not exist`);\n        }\n      }\n    }\n\n    return {\n      valid: errors.length === 0,\n      errors,\n    };\n  } catch {\n    return {\n      valid: true,\n      errors: [],\n    };\n  }\n}\n"],"mappings":"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"}

package/dist/config/schema.cjs

@@ -0,0 +1,99 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+let _aigne_afs = require("@aigne/afs");
+let zod = require("zod");
+
+//#region src/config/schema.ts
+/**
+* Characters forbidden in namespace names (security-sensitive)
+*/
+const NAMESPACE_FORBIDDEN_CHARS = [
+	"/",
+	"\\",
+	":",
+	";",
+	"|",
+	"&",
+	"`",
+	"$",
+	"(",
+	")",
+	">",
+	"<",
+	"\n",
+	"\r",
+	"	",
+	"\0"
+];
+/**
+* Validate namespace name
+*/
+function validateNamespace(namespace) {
+	if (!namespace || namespace.trim() === "") throw new Error("Namespace cannot be empty or whitespace-only");
+	for (const char of NAMESPACE_FORBIDDEN_CHARS) if (namespace.includes(char)) throw new Error(`Namespace contains forbidden character: '${char}'`);
+	return namespace;
+}
+/**
+* Mount configuration schema
+*/
+const MountSchema = zod.z.object({
+	path: zod.z.string().transform((val, ctx) => {
+		try {
+			return (0, _aigne_afs.validatePath)(val);
+		} catch (e) {
+			const message = e instanceof _aigne_afs.AFSPathError ? e.message : "Invalid path";
+			ctx.addIssue({
+				code: zod.z.ZodIssueCode.custom,
+				message
+			});
+			return zod.z.NEVER;
+		}
+	}),
+	uri: zod.z.string().min(1, "URI is required"),
+	namespace: zod.z.string().transform((val, ctx) => {
+		try {
+			return validateNamespace(val);
+		} catch (e) {
+			ctx.addIssue({
+				code: zod.z.ZodIssueCode.custom,
+				message: e instanceof Error ? e.message : "Invalid namespace"
+			});
+			return zod.z.NEVER;
+		}
+	}).optional(),
+	description: zod.z.string().optional(),
+	access_mode: zod.z.enum(["readonly", "readwrite"]).optional(),
+	auth: zod.z.string().optional(),
+	token: zod.z.string().optional(),
+	options: zod.z.record(zod.z.string(), zod.z.unknown()).optional()
+});
+/**
+* Serve configuration schema
+*/
+const ServeSchema = zod.z.object({
+	host: zod.z.string().default("localhost"),
+	port: zod.z.number().int().positive().default(3e3),
+	path: zod.z.string().default("/afs"),
+	readonly: zod.z.boolean().default(false),
+	cors: zod.z.boolean().default(false),
+	max_body_size: zod.z.number().int().positive().default(10 * 1024 * 1024),
+	token: zod.z.string().optional()
+});
+/**
+* Registry configuration schema
+*/
+const RegistrySchema = zod.z.object({
+	enabled: zod.z.boolean().default(true),
+	providers: zod.z.array(zod.z.record(zod.z.string(), zod.z.unknown())).optional()
+});
+/**
+* Root configuration schema for afs.toml
+*/
+const ConfigSchema = zod.z.object({
+	mounts: zod.z.array(MountSchema).default([]),
+	serve: ServeSchema.optional(),
+	registry: RegistrySchema.optional()
+});
+
+//#endregion
+exports.ConfigSchema = ConfigSchema;
+exports.MountSchema = MountSchema;