@mastra/mesa 0.2.0-alpha.0 → 0.2.1-alpha.0

package/dist/index.js

@@ -1,520 +1,526 @@
-import path from 'path/posix';
-import { MastraFilesystem, FileExistsError, NotDirectoryError, FileNotFoundError, DirectoryNotFoundError, IsDirectoryError, DirectoryNotEmptyError, WorkspaceReadOnlyError, StaleFileError } from '@mastra/core/workspace';
-import { Mesa } from '@mesadev/sdk';
-
-// src/filesystem/index.ts
+import path from "path/posix";
+import { DirectoryNotEmptyError, DirectoryNotFoundError, FileExistsError, FileNotFoundError, IsDirectoryError, MastraFilesystem, NotDirectoryError, StaleFileError, WorkspaceReadOnlyError } from "@mastra/core/workspace";
+import { Mesa } from "@mesadev/sdk";
+//#region src/filesystem/index.ts
 function generateId() {
-  return `mesa-fs-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
+	return `mesa-fs-${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 8)}`;
 }
 function normalizePath(inputPath) {
-  return path.normalize(inputPath.startsWith("/") ? inputPath : `/${inputPath}`);
+	return path.normalize(inputPath.startsWith("/") ? inputPath : `/${inputPath}`);
 }
 function getExtension(name) {
-  const dot = name.lastIndexOf(".");
-  return dot === -1 ? "" : name.slice(dot);
+	const dot = name.lastIndexOf(".");
+	return dot === -1 ? "" : name.slice(dot);
 }
 function matchesExtension(name, extensions) {
-  if (!extensions) return true;
-  const ext = getExtension(name);
-  return extensions.some((candidate) => candidate === ext || candidate === ext.slice(1));
+	if (!extensions) return true;
+	const ext = getExtension(name);
+	return extensions.some((candidate) => candidate === ext || candidate === ext.slice(1));
 }
 function toMesaContent(content) {
-  if (typeof content === "string") return content;
-  if (Buffer.isBuffer(content)) return new Uint8Array(content);
-  return content;
+	if (typeof content === "string") return content;
+	if (Buffer.isBuffer(content)) return new Uint8Array(content);
+	return content;
 }
 function toError(error) {
-  return error instanceof Error ? error : new Error(String(error));
+	return error instanceof Error ? error : new Error(String(error));
 }
 function getMesaErrorKind(error) {
-  const err = error && typeof error === "object" ? error : void 0;
-  const code = typeof err?.code === "string" ? err.code : void 0;
-  const name = typeof err?.name === "string" ? err.name : void 0;
-  for (const value of [code, name]) {
-    switch (value) {
-      case "ENOENT":
-      case "NotFound":
-      case "NoSuchFile":
-      case "NoSuchKey":
-        return "notFound";
-      case "EEXIST":
-      case "AlreadyExists":
-        return "alreadyExists";
-      case "ENOTDIR":
-      case "NotDirectory":
-        return "notDirectory";
-      case "EISDIR":
-      case "IsDirectory":
-        return "isDirectory";
-      case "ENOTEMPTY":
-      case "DirectoryNotEmpty":
-        return "directoryNotEmpty";
-    }
-  }
-  const message = typeof err?.message === "string" ? err.message : error instanceof Error ? error.message : String(error);
-  if (/\b(no such file|not found|enoent)\b/i.test(message)) return "notFound";
-  if (/\b(already exists|eexist)\b/i.test(message)) return "alreadyExists";
-  if (/\b(not a directory|enotdir)\b/i.test(message)) return "notDirectory";
-  if (/\b(is a directory|eisdir)\b/i.test(message)) return "isDirectory";
-  if (/\b(directory not empty|enotempty)\b/i.test(message)) return "directoryNotEmpty";
-  return void 0;
+	const err = error && typeof error === "object" ? error : void 0;
+	const code = typeof err?.code === "string" ? err.code : void 0;
+	const name = typeof err?.name === "string" ? err.name : void 0;
+	for (const value of [code, name]) switch (value) {
+		case "ENOENT":
+		case "NotFound":
+		case "NoSuchFile":
+		case "NoSuchKey": return "notFound";
+		case "EEXIST":
+		case "AlreadyExists": return "alreadyExists";
+		case "ENOTDIR":
+		case "NotDirectory": return "notDirectory";
+		case "EISDIR":
+		case "IsDirectory": return "isDirectory";
+		case "ENOTEMPTY":
+		case "DirectoryNotEmpty": return "directoryNotEmpty";
+	}
+	const message = typeof err?.message === "string" ? err.message : error instanceof Error ? error.message : String(error);
+	if (/\b(no such file|not found|enoent)\b/i.test(message)) return "notFound";
+	if (/\b(already exists|eexist)\b/i.test(message)) return "alreadyExists";
+	if (/\b(not a directory|enotdir)\b/i.test(message)) return "notDirectory";
+	if (/\b(is a directory|eisdir)\b/i.test(message)) return "isDirectory";
+	if (/\b(directory not empty|enotempty)\b/i.test(message)) return "directoryNotEmpty";
 }
 function mapMesaError(error, inputPath, context = "file") {
-  switch (getMesaErrorKind(error)) {
-    case "notFound":
-      return context === "directory" ? new DirectoryNotFoundError(inputPath) : new FileNotFoundError(inputPath);
-    case "alreadyExists":
-      return new FileExistsError(inputPath);
-    case "notDirectory":
-      return new NotDirectoryError(inputPath);
-    case "isDirectory":
-      return new IsDirectoryError(inputPath);
-    case "directoryNotEmpty":
-      return new DirectoryNotEmptyError(inputPath);
-    default:
-      return toError(error);
-  }
+	switch (getMesaErrorKind(error)) {
+		case "notFound": return context === "directory" ? new DirectoryNotFoundError(inputPath) : new FileNotFoundError(inputPath);
+		case "alreadyExists": return new FileExistsError(inputPath);
+		case "notDirectory": return new NotDirectoryError(inputPath);
+		case "isDirectory": return new IsDirectoryError(inputPath);
+		case "directoryNotEmpty": return new DirectoryNotEmptyError(inputPath);
+		default: return toError(error);
+	}
 }
+/**
+* Workspace filesystem adapter backed by Mesa.
+*
+* This provider runs in the Mastra process and implements the workspace file
+* API against Mesa repos. It does not mount Mesa into a sandbox.
+*/
 var MesaFilesystem = class extends MastraFilesystem {
-  id;
-  name = "MesaFilesystem";
-  provider = "mesa";
-  readOnly;
-  icon = "mesa";
-  displayName = "Mesa";
-  description = "Versioned Mesa filesystem for workspace files";
-  status = "pending";
-  _apiKey;
-  _org;
-  _repos;
-  _cache;
-  _ttl;
-  _telemetry;
-  _fetch;
-  _userAgent;
-  _mesa;
-  _filesystem;
-  constructor(options) {
-    super({ name: "MesaFilesystem", ...options });
-    this.id = generateId();
-    this.readOnly = options.readOnly;
-    this._org = options.org;
-    this._repos = options.repos;
-    this._apiKey = options.apiKey;
-    this._cache = options.cache;
-    this._ttl = options.ttl;
-    this._telemetry = options.telemetry;
-    this._fetch = options.fetch;
-    this._userAgent = options.userAgent;
-  }
-  /**
-   * The active Mesa client, available after initialization when this instance
-   * created the client itself.
-   */
-  get client() {
-    return this._mesa;
-  }
-  /**
-   * The active Mesa filesystem. Accessing this before initialization throws.
-   */
-  get filesystem() {
-    if (!this._filesystem) {
-      throw new Error("MesaFilesystem is not initialized. Call init() first or perform a filesystem operation.");
-    }
-    return this._filesystem;
-  }
-  async init() {
-    if (!this._repos || this._repos.length === 0) {
-      throw new Error("MesaFilesystem requires at least one repo.");
-    }
-    this._mesa = new Mesa({
-      apiKey: this._apiKey,
-      org: this._org,
-      fetch: this._fetch,
-      userAgent: this._userAgent
-    });
-    const repos = this.readOnly ? this._repos.map((repo) => ({ ...repo, readOnly: true })) : this._repos;
-    this._filesystem = await this._mesa.fs.mount({
-      repos,
-      cache: this._cache,
-      ttl: this._ttl,
-      telemetry: this._telemetry
-    });
-  }
-  getInfo() {
-    return {
-      id: this.id,
-      name: this.name,
-      provider: this.provider,
-      status: this.status,
-      error: this.error,
-      readOnly: this.readOnly,
-      icon: this.icon,
-      metadata: {
-        ...this._org && { org: this._org },
-        ...this._repos && { repos: this._repos.map((repo) => repo.name) },
-        mode: "client"
-      }
-    };
-  }
-  getInstructions() {
-    const parts = ["Mesa filesystem. Paths are rooted at the Mesa mount. Include the org and repo name in paths."];
-    if (this._org) {
-      parts.push(`Org: "${this._org}".`);
-    } else {
-      parts.push("Use the Mesa org resolved by the SDK as the first path segment.");
-    }
-    if (this._repos && this._repos.length > 0) {
-      const repoNames = this._repos.map((repo) => `"${repo.name}"`).join(", ");
-      const firstRepo = this._repos[0]?.name ?? "repo";
-      const orgSegment = this._org ?? "org";
-      parts.push(`Mounted repos: ${repoNames}. For example "/${orgSegment}/${firstRepo}/file.txt".`);
-    }
-    parts.push("Files are versioned by Mesa.");
-    if (this.readOnly) {
-      parts.push("Mounted read-only.");
-    }
-    return parts.join(" ");
-  }
-  async readFile(inputPath, options) {
-    await this.ensureReady();
-    const target = normalizePath(inputPath);
-    try {
-      const buffer = Buffer.from(await this.filesystem.readFileBuffer(target));
-      if (options?.encoding) return buffer.toString(options.encoding);
-      return buffer;
-    } catch (error) {
-      throw mapMesaError(error, inputPath);
-    }
-  }
-  async writeFile(inputPath, content, options) {
-    await this.ensureReady();
-    this.assertWritable("writeFile");
-    const target = normalizePath(inputPath);
-    if (options?.overwrite === false && await this.exists(target)) {
-      throw new FileExistsError(inputPath);
-    }
-    if (options?.expectedMtime) {
-      await this.assertExpectedMtime(inputPath, options.expectedMtime);
-    }
-    if (options?.recursive === false) {
-      await this.assertParentDirectoryExists(target);
-    } else {
-      await this.ensureParentDirectory(target);
-    }
-    try {
-      await this.filesystem.writeFile(target, toMesaContent(content));
-    } catch (error) {
-      const mapped = mapMesaError(error, inputPath);
-      if (mapped instanceof NotDirectoryError) throw new NotDirectoryError(path.dirname(target));
-      if (mapped instanceof FileNotFoundError) throw new DirectoryNotFoundError(path.dirname(target));
-      throw mapped;
-    }
-  }
-  async appendFile(inputPath, content) {
-    await this.ensureReady();
-    this.assertWritable("appendFile");
-    const target = normalizePath(inputPath);
-    await this.ensureParentDirectory(target);
-    try {
-      await this.filesystem.appendFile(target, toMesaContent(content));
-    } catch (error) {
-      const mapped = mapMesaError(error, inputPath);
-      if (mapped instanceof FileNotFoundError) throw new DirectoryNotFoundError(path.dirname(target));
-      throw mapped;
-    }
-  }
-  async deleteFile(inputPath, options) {
-    await this.ensureReady();
-    this.assertWritable("deleteFile");
-    const target = normalizePath(inputPath);
-    try {
-      const stats = await this.filesystem.stat(target);
-      if (stats.isDirectory) throw new IsDirectoryError(inputPath);
-      await this.filesystem.rm(target, { force: options?.force });
-    } catch (error) {
-      if (error instanceof IsDirectoryError) throw error;
-      const mapped = mapMesaError(error, inputPath);
-      if (mapped instanceof FileNotFoundError) {
-        if (options?.force) return;
-        throw mapped;
-      }
-      throw mapped;
-    }
-  }
-  async copyFile(src, dest, options) {
-    await this.ensureReady();
-    this.assertWritable("copyFile");
-    const source = normalizePath(src);
-    const target = normalizePath(dest);
-    if (options?.overwrite === false && await this.exists(target)) {
-      throw new FileExistsError(dest);
-    }
-    await this.ensureParentDirectory(target);
-    try {
-      await this.filesystem.cp(source, target, { recursive: options?.recursive });
-    } catch (error) {
-      const mapped = mapMesaError(error, src);
-      if (mapped instanceof FileExistsError) throw new FileExistsError(dest);
-      throw mapped;
-    }
-  }
-  async moveFile(src, dest, options) {
-    await this.ensureReady();
-    this.assertWritable("moveFile");
-    const source = normalizePath(src);
-    const target = normalizePath(dest);
-    if (options?.overwrite === false && await this.exists(target)) {
-      throw new FileExistsError(dest);
-    }
-    await this.ensureParentDirectory(target);
-    try {
-      await this.filesystem.mv(source, target);
-    } catch (error) {
-      const mapped = mapMesaError(error, src);
-      if (mapped instanceof FileExistsError) throw new FileExistsError(dest);
-      throw mapped;
-    }
-  }
-  async mkdir(inputPath, options) {
-    await this.ensureReady();
-    this.assertWritable("mkdir");
-    const target = normalizePath(inputPath);
-    try {
-      await this.filesystem.mkdir(target, { recursive: options?.recursive ?? true });
-    } catch (error) {
-      const mapped = mapMesaError(error, inputPath);
-      if (mapped instanceof FileNotFoundError) throw new DirectoryNotFoundError(path.dirname(target));
-      throw mapped;
-    }
-  }
-  async rmdir(inputPath, options) {
-    await this.ensureReady();
-    this.assertWritable("rmdir");
-    const target = normalizePath(inputPath);
-    try {
-      const stats = await this.filesystem.stat(target);
-      if (!stats.isDirectory) throw new NotDirectoryError(inputPath);
-      if (!options?.recursive) {
-        const entries = await this.filesystem.readdirWithFileTypes(target);
-        if (entries.length > 0) throw new DirectoryNotEmptyError(inputPath);
-      }
-      await this.filesystem.rm(target, { recursive: options?.recursive ?? true, force: options?.force });
-    } catch (error) {
-      if (error instanceof NotDirectoryError) throw error;
-      if (error instanceof DirectoryNotEmptyError) throw error;
-      const mapped = mapMesaError(error, inputPath, "directory");
-      if (mapped instanceof DirectoryNotFoundError) {
-        if (options?.force) return;
-        throw mapped;
-      }
-      throw mapped;
-    }
-  }
-  async readdir(inputPath, options) {
-    await this.ensureReady();
-    const target = normalizePath(inputPath);
-    try {
-      return await this.readDirectory(target, options);
-    } catch (error) {
-      throw mapMesaError(error, inputPath, "directory");
-    }
-  }
-  async exists(inputPath) {
-    await this.ensureReady();
-    const target = normalizePath(inputPath);
-    try {
-      return await this.filesystem.exists(target);
-    } catch (error) {
-      if (getMesaErrorKind(error) === "notFound") return false;
-      throw mapMesaError(error, inputPath);
-    }
-  }
-  async stat(inputPath) {
-    await this.ensureReady();
-    const target = normalizePath(inputPath);
-    try {
-      const stats = await this.filesystem.stat(target);
-      return this.toFileStat(target, stats);
-    } catch (error) {
-      throw mapMesaError(error, inputPath);
-    }
-  }
-  async realpath(inputPath) {
-    await this.ensureReady();
-    try {
-      return await this.filesystem.realpath(normalizePath(inputPath));
-    } catch (error) {
-      throw mapMesaError(error, inputPath);
-    }
-  }
-  /**
-   * Create a Mesa-backed Bash runtime for this filesystem.
-   */
-  async bash(options) {
-    await this.ensureReady();
-    return this.filesystem.bash(options);
-  }
-  /**
-   * Mesa change management operations for the mounted filesystem.
-   */
-  get change() {
-    return this.filesystem.change;
-  }
-  /**
-   * Mesa bookmark management operations for the mounted filesystem.
-   */
-  get bookmark() {
-    return this.filesystem.bookmark;
-  }
-  assertWritable(operation) {
-    if (this.readOnly) {
-      throw new WorkspaceReadOnlyError(operation);
-    }
-  }
-  async assertExpectedMtime(inputPath, expectedMtime) {
-    try {
-      const currentStat = await this.stat(inputPath);
-      if (currentStat.modifiedAt.getTime() !== expectedMtime.getTime()) {
-        throw new StaleFileError(inputPath, expectedMtime, currentStat.modifiedAt);
-      }
-    } catch (error) {
-      if (error instanceof StaleFileError) throw error;
-      if (error instanceof FileNotFoundError) return;
-      throw error;
-    }
-  }
-  async ensureParentDirectory(inputPath) {
-    const parent = path.dirname(inputPath);
-    if (parent === "/" || parent === inputPath) return;
-    try {
-      await this.filesystem.mkdir(parent, { recursive: true });
-    } catch (error) {
-      const mapped = mapMesaError(error, parent, "directory");
-      if (!(mapped instanceof FileExistsError)) throw mapped;
-      try {
-        const stats = await this.filesystem.stat(parent);
-        if (!stats.isDirectory) {
-          throw new NotDirectoryError(parent);
-        }
-      } catch (statError) {
-        if (statError instanceof NotDirectoryError) throw statError;
-        throw mapMesaError(statError, parent, "directory");
-      }
-    }
-  }
-  async assertParentDirectoryExists(inputPath) {
-    const parent = path.dirname(inputPath);
-    if (parent === "/" || parent === inputPath) return;
-    try {
-      const stats = await this.filesystem.stat(parent);
-      if (!stats.isDirectory) {
-        throw new NotDirectoryError(parent);
-      }
-    } catch (error) {
-      if (error instanceof NotDirectoryError) throw error;
-      throw mapMesaError(error, parent, "directory");
-    }
-  }
-  async readDirectory(inputPath, options, depth = 0) {
-    const entries = await this.filesystem.readdirWithFileTypes(inputPath);
-    const extensions = options?.extension ? Array.isArray(options.extension) ? options.extension : [options.extension] : void 0;
-    const result = [];
-    for (const entry of entries) {
-      const childPath = path.join(inputPath, entry.name);
-      if (entry.isFile) {
-        if (matchesExtension(entry.name, extensions)) {
-          const stat = await this.safeStat(childPath);
-          result.push({ name: entry.name, type: "file", size: stat?.size });
-        }
-        continue;
-      }
-      if (entry.isDirectory) {
-        result.push({ name: entry.name, type: "directory" });
-        if (options?.recursive && (options.maxDepth === void 0 || depth < options.maxDepth)) {
-          const childEntries = await this.readDirectory(childPath, options, depth + 1);
-          result.push(...childEntries.map((child) => ({ ...child, name: `${entry.name}/${child.name}` })));
-        }
-        continue;
-      }
-      result.push(this.toFileEntry(entry));
-    }
-    return result;
-  }
-  async safeStat(inputPath) {
-    try {
-      return await this.filesystem.stat(inputPath);
-    } catch {
-      return void 0;
-    }
-  }
-  toFileEntry(entry) {
-    return {
-      name: entry.name,
-      type: entry.isDirectory ? "directory" : "file",
-      isSymlink: entry.isSymbolicLink || void 0
-    };
-  }
-  toFileStat(inputPath, stats) {
-    const target = normalizePath(inputPath);
-    return {
-      name: target === "/" ? "/" : path.basename(target),
-      path: target,
-      type: stats.isDirectory ? "directory" : "file",
-      size: stats.isDirectory ? 0 : stats.size,
-      createdAt: stats.mtime,
-      modifiedAt: stats.mtime
-    };
-  }
+	id;
+	name = "MesaFilesystem";
+	provider = "mesa";
+	readOnly;
+	icon = "mesa";
+	displayName = "Mesa";
+	description = "Versioned Mesa filesystem for workspace files";
+	status = "pending";
+	_apiKey;
+	_org;
+	_repos;
+	_cache;
+	_ttl;
+	_telemetry;
+	_fetch;
+	_userAgent;
+	_mesa;
+	_filesystem;
+	constructor(options) {
+		super({
+			name: "MesaFilesystem",
+			...options
+		});
+		this.id = generateId();
+		this.readOnly = options.readOnly;
+		this._org = options.org;
+		this._repos = options.repos;
+		this._apiKey = options.apiKey;
+		this._cache = options.cache;
+		this._ttl = options.ttl;
+		this._telemetry = options.telemetry;
+		this._fetch = options.fetch;
+		this._userAgent = options.userAgent;
+	}
+	/**
+	* The active Mesa client, available after initialization when this instance
+	* created the client itself.
+	*/
+	get client() {
+		return this._mesa;
+	}
+	/**
+	* The active Mesa filesystem. Accessing this before initialization throws.
+	*/
+	get filesystem() {
+		if (!this._filesystem) throw new Error("MesaFilesystem is not initialized. Call init() first or perform a filesystem operation.");
+		return this._filesystem;
+	}
+	async init() {
+		if (!this._repos || this._repos.length === 0) throw new Error("MesaFilesystem requires at least one repo.");
+		this._mesa = new Mesa({
+			apiKey: this._apiKey,
+			org: this._org,
+			fetch: this._fetch,
+			userAgent: this._userAgent
+		});
+		const repos = this.readOnly ? this._repos.map((repo) => ({
+			...repo,
+			readOnly: true
+		})) : this._repos;
+		this._filesystem = await this._mesa.fs.mount({
+			repos,
+			cache: this._cache,
+			ttl: this._ttl,
+			telemetry: this._telemetry
+		});
+	}
+	getInfo() {
+		return {
+			id: this.id,
+			name: this.name,
+			provider: this.provider,
+			status: this.status,
+			error: this.error,
+			readOnly: this.readOnly,
+			icon: this.icon,
+			metadata: {
+				...this._org && { org: this._org },
+				...this._repos && { repos: this._repos.map((repo) => repo.name) },
+				mode: "client"
+			}
+		};
+	}
+	getInstructions() {
+		const parts = ["Mesa filesystem. Paths are rooted at the Mesa mount. Include the org and repo name in paths."];
+		if (this._org) parts.push(`Org: "${this._org}".`);
+		else parts.push("Use the Mesa org resolved by the SDK as the first path segment.");
+		if (this._repos && this._repos.length > 0) {
+			const repoNames = this._repos.map((repo) => `"${repo.name}"`).join(", ");
+			const firstRepo = this._repos[0]?.name ?? "repo";
+			const orgSegment = this._org ?? "org";
+			parts.push(`Mounted repos: ${repoNames}. For example "/${orgSegment}/${firstRepo}/file.txt".`);
+		}
+		parts.push("Files are versioned by Mesa.");
+		if (this.readOnly) parts.push("Mounted read-only.");
+		return parts.join(" ");
+	}
+	async readFile(inputPath, options) {
+		await this.ensureReady();
+		const target = normalizePath(inputPath);
+		try {
+			const buffer = Buffer.from(await this.filesystem.readFileBuffer(target));
+			if (options?.encoding) return buffer.toString(options.encoding);
+			return buffer;
+		} catch (error) {
+			throw mapMesaError(error, inputPath);
+		}
+	}
+	async writeFile(inputPath, content, options) {
+		await this.ensureReady();
+		this.assertWritable("writeFile");
+		const target = normalizePath(inputPath);
+		if (options?.overwrite === false && await this.exists(target)) throw new FileExistsError(inputPath);
+		if (options?.expectedMtime) await this.assertExpectedMtime(inputPath, options.expectedMtime);
+		if (options?.recursive === false) await this.assertParentDirectoryExists(target);
+		else await this.ensureParentDirectory(target);
+		try {
+			await this.filesystem.writeFile(target, toMesaContent(content));
+		} catch (error) {
+			const mapped = mapMesaError(error, inputPath);
+			if (mapped instanceof NotDirectoryError) throw new NotDirectoryError(path.dirname(target));
+			if (mapped instanceof FileNotFoundError) throw new DirectoryNotFoundError(path.dirname(target));
+			throw mapped;
+		}
+	}
+	async appendFile(inputPath, content) {
+		await this.ensureReady();
+		this.assertWritable("appendFile");
+		const target = normalizePath(inputPath);
+		await this.ensureParentDirectory(target);
+		try {
+			await this.filesystem.appendFile(target, toMesaContent(content));
+		} catch (error) {
+			const mapped = mapMesaError(error, inputPath);
+			if (mapped instanceof FileNotFoundError) throw new DirectoryNotFoundError(path.dirname(target));
+			throw mapped;
+		}
+	}
+	async deleteFile(inputPath, options) {
+		await this.ensureReady();
+		this.assertWritable("deleteFile");
+		const target = normalizePath(inputPath);
+		try {
+			if ((await this.filesystem.stat(target)).isDirectory) throw new IsDirectoryError(inputPath);
+			await this.filesystem.rm(target, { force: options?.force });
+		} catch (error) {
+			if (error instanceof IsDirectoryError) throw error;
+			const mapped = mapMesaError(error, inputPath);
+			if (mapped instanceof FileNotFoundError) {
+				if (options?.force) return;
+				throw mapped;
+			}
+			throw mapped;
+		}
+	}
+	async copyFile(src, dest, options) {
+		await this.ensureReady();
+		this.assertWritable("copyFile");
+		const source = normalizePath(src);
+		const target = normalizePath(dest);
+		if (options?.overwrite === false && await this.exists(target)) throw new FileExistsError(dest);
+		await this.ensureParentDirectory(target);
+		try {
+			await this.filesystem.cp(source, target, { recursive: options?.recursive });
+		} catch (error) {
+			const mapped = mapMesaError(error, src);
+			if (mapped instanceof FileExistsError) throw new FileExistsError(dest);
+			throw mapped;
+		}
+	}
+	async moveFile(src, dest, options) {
+		await this.ensureReady();
+		this.assertWritable("moveFile");
+		const source = normalizePath(src);
+		const target = normalizePath(dest);
+		if (options?.overwrite === false && await this.exists(target)) throw new FileExistsError(dest);
+		await this.ensureParentDirectory(target);
+		try {
+			await this.filesystem.mv(source, target);
+		} catch (error) {
+			const mapped = mapMesaError(error, src);
+			if (mapped instanceof FileExistsError) throw new FileExistsError(dest);
+			throw mapped;
+		}
+	}
+	async mkdir(inputPath, options) {
+		await this.ensureReady();
+		this.assertWritable("mkdir");
+		const target = normalizePath(inputPath);
+		try {
+			await this.filesystem.mkdir(target, { recursive: options?.recursive ?? true });
+		} catch (error) {
+			const mapped = mapMesaError(error, inputPath);
+			if (mapped instanceof FileNotFoundError) throw new DirectoryNotFoundError(path.dirname(target));
+			throw mapped;
+		}
+	}
+	async rmdir(inputPath, options) {
+		await this.ensureReady();
+		this.assertWritable("rmdir");
+		const target = normalizePath(inputPath);
+		try {
+			if (!(await this.filesystem.stat(target)).isDirectory) throw new NotDirectoryError(inputPath);
+			if (!options?.recursive) {
+				if ((await this.filesystem.readdirWithFileTypes(target)).length > 0) throw new DirectoryNotEmptyError(inputPath);
+			}
+			await this.filesystem.rm(target, {
+				recursive: options?.recursive ?? true,
+				force: options?.force
+			});
+		} catch (error) {
+			if (error instanceof NotDirectoryError) throw error;
+			if (error instanceof DirectoryNotEmptyError) throw error;
+			const mapped = mapMesaError(error, inputPath, "directory");
+			if (mapped instanceof DirectoryNotFoundError) {
+				if (options?.force) return;
+				throw mapped;
+			}
+			throw mapped;
+		}
+	}
+	async readdir(inputPath, options) {
+		await this.ensureReady();
+		const target = normalizePath(inputPath);
+		try {
+			return await this.readDirectory(target, options);
+		} catch (error) {
+			throw mapMesaError(error, inputPath, "directory");
+		}
+	}
+	async exists(inputPath) {
+		await this.ensureReady();
+		const target = normalizePath(inputPath);
+		try {
+			return await this.filesystem.exists(target);
+		} catch (error) {
+			if (getMesaErrorKind(error) === "notFound") return false;
+			throw mapMesaError(error, inputPath);
+		}
+	}
+	async stat(inputPath) {
+		await this.ensureReady();
+		const target = normalizePath(inputPath);
+		try {
+			const stats = await this.filesystem.stat(target);
+			return this.toFileStat(target, stats);
+		} catch (error) {
+			throw mapMesaError(error, inputPath);
+		}
+	}
+	async realpath(inputPath) {
+		await this.ensureReady();
+		try {
+			return await this.filesystem.realpath(normalizePath(inputPath));
+		} catch (error) {
+			throw mapMesaError(error, inputPath);
+		}
+	}
+	/**
+	* Create a Mesa-backed Bash runtime for this filesystem.
+	*/
+	async bash(options) {
+		await this.ensureReady();
+		return this.filesystem.bash(options);
+	}
+	/**
+	* Mesa change management operations for the mounted filesystem.
+	*/
+	get change() {
+		return this.filesystem.change;
+	}
+	/**
+	* Mesa bookmark management operations for the mounted filesystem.
+	*/
+	get bookmark() {
+		return this.filesystem.bookmark;
+	}
+	assertWritable(operation) {
+		if (this.readOnly) throw new WorkspaceReadOnlyError(operation);
+	}
+	async assertExpectedMtime(inputPath, expectedMtime) {
+		try {
+			const currentStat = await this.stat(inputPath);
+			if (currentStat.modifiedAt.getTime() !== expectedMtime.getTime()) throw new StaleFileError(inputPath, expectedMtime, currentStat.modifiedAt);
+		} catch (error) {
+			if (error instanceof StaleFileError) throw error;
+			if (error instanceof FileNotFoundError) return;
+			throw error;
+		}
+	}
+	async ensureParentDirectory(inputPath) {
+		const parent = path.dirname(inputPath);
+		if (parent === "/" || parent === inputPath) return;
+		try {
+			await this.filesystem.mkdir(parent, { recursive: true });
+		} catch (error) {
+			const mapped = mapMesaError(error, parent, "directory");
+			if (!(mapped instanceof FileExistsError)) throw mapped;
+			try {
+				if (!(await this.filesystem.stat(parent)).isDirectory) throw new NotDirectoryError(parent);
+			} catch (statError) {
+				if (statError instanceof NotDirectoryError) throw statError;
+				throw mapMesaError(statError, parent, "directory");
+			}
+		}
+	}
+	async assertParentDirectoryExists(inputPath) {
+		const parent = path.dirname(inputPath);
+		if (parent === "/" || parent === inputPath) return;
+		try {
+			if (!(await this.filesystem.stat(parent)).isDirectory) throw new NotDirectoryError(parent);
+		} catch (error) {
+			if (error instanceof NotDirectoryError) throw error;
+			throw mapMesaError(error, parent, "directory");
+		}
+	}
+	async readDirectory(inputPath, options, depth = 0) {
+		const entries = await this.filesystem.readdirWithFileTypes(inputPath);
+		const extensions = options?.extension ? Array.isArray(options.extension) ? options.extension : [options.extension] : void 0;
+		const result = [];
+		for (const entry of entries) {
+			const childPath = path.join(inputPath, entry.name);
+			if (entry.isFile) {
+				if (matchesExtension(entry.name, extensions)) {
+					const stat = await this.safeStat(childPath);
+					result.push({
+						name: entry.name,
+						type: "file",
+						size: stat?.size
+					});
+				}
+				continue;
+			}
+			if (entry.isDirectory) {
+				result.push({
+					name: entry.name,
+					type: "directory"
+				});
+				if (options?.recursive && (options.maxDepth === void 0 || depth < options.maxDepth)) {
+					const childEntries = await this.readDirectory(childPath, options, depth + 1);
+					result.push(...childEntries.map((child) => ({
+						...child,
+						name: `${entry.name}/${child.name}`
+					})));
+				}
+				continue;
+			}
+			result.push(this.toFileEntry(entry));
+		}
+		return result;
+	}
+	async safeStat(inputPath) {
+		try {
+			return await this.filesystem.stat(inputPath);
+		} catch {
+			return;
+		}
+	}
+	toFileEntry(entry) {
+		return {
+			name: entry.name,
+			type: entry.isDirectory ? "directory" : "file",
+			isSymlink: entry.isSymbolicLink || void 0
+		};
+	}
+	toFileStat(inputPath, stats) {
+		const target = normalizePath(inputPath);
+		return {
+			name: target === "/" ? "/" : path.basename(target),
+			path: target,
+			type: stats.isDirectory ? "directory" : "file",
+			size: stats.isDirectory ? 0 : stats.size,
+			createdAt: stats.mtime,
+			modifiedAt: stats.mtime
+		};
+	}
 };
-
-// src/provider.ts
-var mesaFilesystemProvider = {
-  id: "mesa",
-  name: "Mesa",
-  description: "Versioned Mesa filesystem for workspace files",
-  configSchema: {
-    type: "object",
-    required: ["repos"],
-    properties: {
-      apiKey: { type: "string", description: "Mesa API key. Falls back to MESA_API_KEY when omitted." },
-      org: { type: "string", description: "Mesa org slug" },
-      repos: {
-        type: "array",
-        description: "Mesa repos to mount",
-        minItems: 1,
-        items: {
-          type: "object",
-          required: ["name"],
-          properties: {
-            name: { type: "string", description: "Mesa repo name" },
-            bookmark: { type: "string", description: "Bookmark to mount" },
-            changeId: { type: "string", description: "Change ID to mount" },
-            readOnly: { type: "boolean", description: "Mount this repo as read-only" }
-          }
-        }
-      },
-      cache: {
-        type: "object",
-        description: "Mesa filesystem cache configuration",
-        properties: {
-          diskCache: {
-            type: "object",
-            required: ["path"],
-            properties: {
-              path: { type: "string", description: "Disk cache path" },
-              maxSizeBytes: { type: "number", description: "Maximum disk cache size in bytes" }
-            }
-          }
-        }
-      },
-      ttl: { type: "number", description: "Mesa mount token lifetime in seconds" },
-      readOnly: { type: "boolean", description: "Mount all repos as read-only", default: false }
-    }
-  },
-  createFilesystem: (config) => new MesaFilesystem(config)
+//#endregion
+//#region src/provider.ts
+const mesaFilesystemProvider = {
+	id: "mesa",
+	name: "Mesa",
+	description: "Versioned Mesa filesystem for workspace files",
+	configSchema: {
+		type: "object",
+		required: ["repos"],
+		properties: {
+			apiKey: {
+				type: "string",
+				description: "Mesa API key. Falls back to MESA_API_KEY when omitted."
+			},
+			org: {
+				type: "string",
+				description: "Mesa org slug"
+			},
+			repos: {
+				type: "array",
+				description: "Mesa repos to mount",
+				minItems: 1,
+				items: {
+					type: "object",
+					required: ["name"],
+					properties: {
+						name: {
+							type: "string",
+							description: "Mesa repo name"
+						},
+						bookmark: {
+							type: "string",
+							description: "Bookmark to mount"
+						},
+						changeId: {
+							type: "string",
+							description: "Change ID to mount"
+						},
+						readOnly: {
+							type: "boolean",
+							description: "Mount this repo as read-only"
+						}
+					}
+				}
+			},
+			cache: {
+				type: "object",
+				description: "Mesa filesystem cache configuration",
+				properties: { diskCache: {
+					type: "object",
+					required: ["path"],
+					properties: {
+						path: {
+							type: "string",
+							description: "Disk cache path"
+						},
+						maxSizeBytes: {
+							type: "number",
+							description: "Maximum disk cache size in bytes"
+						}
+					}
+				} }
+			},
+			ttl: {
+				type: "number",
+				description: "Mesa mount token lifetime in seconds"
+			},
+			readOnly: {
+				type: "boolean",
+				description: "Mount all repos as read-only",
+				default: false
+			}
+		}
+	},
+	createFilesystem: (config) => new MesaFilesystem(config)
 };
-
+//#endregion
 export { MesaFilesystem, mesaFilesystemProvider };
-//# sourceMappingURL=index.js.map
+
 //# sourceMappingURL=index.js.map