@filebox/ftp-server 1.0.0 → 1.0.1

package/dist/index.cjs

@@ -0,0 +1,965 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FileBoxFtpFileSystem: () => FileBoxFtpFileSystem,
+  FileBoxFtpServer: () => FileBoxFtpServer,
+  createFileBoxFtpSessionFactory: () => createFileBoxFtpSessionFactory,
+  createRuntime: () => createRuntime,
+  createStaticFtpAuthenticator: () => createStaticFtpAuthenticator,
+  createWorkspaceRuntime: () => createWorkspaceRuntime,
+  normalizeServerCredentials: () => normalizeServerCredentials
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/server/index.ts
+var import_ftp_srv = require("ftp-srv");
+
+// src/server/auth.ts
+function normalizeServerCredentials(options) {
+  return {
+    username: options.username || "filebox",
+    password: options.password || "filebox",
+    anonymous: options.anonymous ?? false
+  };
+}
+function createStaticFtpAuthenticator(credentials) {
+  return ({ username, password }) => {
+    if (credentials.anonymous) {
+      return true;
+    }
+    return username === credentials.username && password === credentials.password;
+  };
+}
+
+// src/server/index.ts
+function normalizeServerOptions(options = {}) {
+  const credentials = normalizeServerCredentials(options);
+  return {
+    url: options.url || "ftp://0.0.0.0:2121",
+    username: credentials.username,
+    password: credentials.password,
+    anonymous: credentials.anonymous,
+    passiveUrl: options.passiveUrl ?? null,
+    passivePortMin: options.passivePortMin ?? 3e4,
+    passivePortMax: options.passivePortMax ?? 30999,
+    timeout: options.timeout ?? 0,
+    greeting: options.greeting ?? null,
+    mountedDriveNames: options.mountedDriveNames ?? [],
+    loginLabel: options.loginLabel ?? null,
+    authenticate: options.authenticate,
+    createSession: options.createSession
+  };
+}
+var FileBoxFtpServer = class {
+  options;
+  authenticate;
+  ftpServer = null;
+  constructor(options = {}) {
+    this.options = normalizeServerOptions(options);
+    if (typeof this.options.createSession !== "function") {
+      throw new Error("FileBoxFtpServer requires a createSession handler.");
+    }
+    this.authenticate = this.options.authenticate || createStaticFtpAuthenticator({
+      anonymous: this.options.anonymous,
+      username: this.options.username,
+      password: this.options.password
+    });
+  }
+  async init() {
+    if (this.ftpServer) {
+      return this;
+    }
+    this.ftpServer = new import_ftp_srv.FtpSrv({
+      url: this.options.url,
+      anonymous: this.options.anonymous,
+      pasv_url: this.options.passiveUrl || void 0,
+      pasv_min: this.options.passivePortMin,
+      pasv_max: this.options.passivePortMax,
+      timeout: this.options.timeout,
+      greeting: this.options.greeting || void 0
+    });
+    this.ftpServer.on("login", ({ username, password }, resolve, reject) => {
+      void this.handleLogin({ username, password }, resolve, reject);
+    });
+    return this;
+  }
+  async handleLogin(credentials, resolve, reject) {
+    try {
+      const loginContext = {
+        username: credentials.username,
+        password: credentials.password,
+        anonymous: this.options.anonymous
+      };
+      const authenticated = await this.authenticate(loginContext);
+      if (!authenticated) {
+        reject(new Error("Invalid username or password"));
+        return;
+      }
+      const createSession = this.options.createSession;
+      if (!createSession) {
+        reject(new Error("FTP session factory is not configured."));
+        return;
+      }
+      const session = await createSession(loginContext);
+      if (!session?.fs) {
+        reject(new Error("FTP session must provide a file system instance."));
+        return;
+      }
+      resolve({
+        root: session.root || "/",
+        fs: session.fs
+      });
+    } catch (error) {
+      reject(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+  async listen() {
+    await this.init();
+    await this.ftpServer.listen();
+    return this;
+  }
+  async close() {
+    if (this.ftpServer) {
+      const server = this.ftpServer;
+      this.ftpServer = null;
+      await server.close();
+    }
+  }
+  getFtpServer() {
+    if (!this.ftpServer) {
+      throw new Error("FTP server is not initialized. Call init() first.");
+    }
+    return this.ftpServer;
+  }
+  getSummary() {
+    const loginLabel = this.options.loginLabel || (this.options.anonymous ? "anonymous" : this.options.username);
+    return {
+      url: this.options.url,
+      mountedDriveNames: this.options.mountedDriveNames,
+      passiveUrl: this.options.passiveUrl,
+      passivePortMin: this.options.passivePortMin,
+      passivePortMax: this.options.passivePortMax,
+      anonymous: this.options.anonymous,
+      username: this.options.username,
+      loginLabel,
+      timeout: this.options.timeout
+    };
+  }
+};
+
+// src/filesystem/index.ts
+var import_node_fs = __toESM(require("node:fs"), 1);
+var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_crypto = __toESM(require("node:crypto"), 1);
+var import_node_stream = require("node:stream");
+var import_node_url = require("node:url");
+var import_ftp_srv2 = require("ftp-srv");
+var import_runtime = require("@filebox/runtime");
+
+// src/filesystem/path.ts
+var import_node_path = __toESM(require("node:path"), 1);
+function normalizeFtpClientPath(targetPath) {
+  const normalizedInput = (targetPath || "/").trim();
+  if (normalizedInput === "" || normalizedInput === "." || normalizedInput === "./") {
+    return "/";
+  }
+  const normalized = import_node_path.default.posix.normalize(normalizedInput);
+  if (normalized === "." || normalized === "/.") {
+    return "/";
+  }
+  return normalized.startsWith("/") ? normalized : `/${normalized}`;
+}
+
+// src/filesystem/index.ts
+function asDate(input) {
+  const date = input ? new Date(String(input)) : /* @__PURE__ */ new Date(0);
+  return Number.isNaN(date.getTime()) ? /* @__PURE__ */ new Date(0) : date;
+}
+function toFileSystemError(error) {
+  const message = error instanceof Error ? error.message : typeof error === "string" ? error : "File system error";
+  return new Error(message);
+}
+function toFileEntry(stat) {
+  const isDirectory = stat?.type === "folder" || stat?.directory === true;
+  const byteSize = typeof stat?.byte === "number" ? stat.byte : typeof stat?.size === "number" ? stat.size : 0;
+  return {
+    name: stat?.name || "",
+    size: Number.isFinite(byteSize) ? byteSize : 0,
+    atime: asDate(stat?.atime),
+    mtime: asDate(stat?.mtime),
+    ctime: asDate(stat?.ctime),
+    birthtime: asDate(stat?.ctime),
+    isDirectory: () => isDirectory,
+    isFile: () => !isDirectory
+  };
+}
+function createUploadFileMetadata(tempFilePath, fileName, workspaceRoot) {
+  const stats = import_node_fs.default.statSync(tempFilePath);
+  const parsedPath = import_node_path2.default.parse(tempFilePath);
+  const relativeBase = workspaceRoot || import_node_path2.default.dirname(tempFilePath);
+  return {
+    path: parsedPath.dir,
+    name: fileName,
+    baseName: import_node_path2.default.parse(fileName).name,
+    ext: import_node_path2.default.parse(fileName).ext,
+    size: stats.size,
+    absolutePath: tempFilePath,
+    relativePath: import_node_path2.default.relative(relativeBase, tempFilePath),
+    mimeType: "",
+    lastModified: stats.mtime,
+    parentPath: parsedPath.dir,
+    isFile: true,
+    isDirectory: false,
+    md5: async () => calculateMd5(tempFilePath)
+  };
+}
+function calculateMd5(filePath) {
+  return new Promise((resolve, reject) => {
+    const hash = import_node_crypto.default.createHash("md5");
+    const input = import_node_fs.default.createReadStream(filePath);
+    input.on("readable", () => {
+      const data = input.read();
+      if (data) {
+        hash.update(data);
+        return;
+      }
+      resolve(hash.digest("hex"));
+    });
+    input.on("error", reject);
+  });
+}
+function resolveReadableDownloadPath(rawUrl) {
+  if (rawUrl.startsWith("file://")) {
+    return (0, import_node_url.fileURLToPath)(rawUrl);
+  }
+  if (import_node_fs.default.existsSync(rawUrl)) {
+    return rawUrl;
+  }
+  return null;
+}
+function parseRemoteResponseTotalSize(response, fallback) {
+  const contentRange = response.headers.get("content-range");
+  if (contentRange) {
+    const match = contentRange.match(/\/(\d+)$/);
+    if (match) {
+      return Number.parseInt(match[1], 10);
+    }
+  }
+  const contentLength = response.headers.get("content-length");
+  if (contentLength) {
+    const size = Number.parseInt(contentLength, 10);
+    if (Number.isFinite(size)) {
+      return size;
+    }
+  }
+  return typeof fallback === "number" && Number.isFinite(fallback) ? fallback : 0;
+}
+function parseDownloadEncryptionProfile(rawUrl) {
+  try {
+    return (0, import_runtime.parseEncryptionQueryParams)(new URL(rawUrl));
+  } catch {
+    return null;
+  }
+}
+function resolveFtpClientReference(currentDirectory, targetPath = ".") {
+  const resolvedPath = targetPath.replace(/\\/g, "/");
+  const clientPath = import_node_path2.default.posix.isAbsolute(resolvedPath) ? import_node_path2.default.posix.normalize(resolvedPath) : import_node_path2.default.posix.join("/", currentDirectory, resolvedPath);
+  return normalizeFtpClientPath(clientPath);
+}
+function resolveFtpDownloadDecryption(input) {
+  const queryProfile = parseDownloadEncryptionProfile(
+    input.downloadInfo.url || ""
+  );
+  const encryptedByName = (0, import_runtime.isContentEncryptedName)(
+    import_node_path2.default.posix.basename(input.clientPath)
+  );
+  if (!encryptedByName && !queryProfile) {
+    return null;
+  }
+  const profile = (0, import_runtime.resolveEncryptionProfile)({
+    password: input.config.encryption?.password,
+    salt: input.config.encryption?.salt,
+    algorithm: queryProfile?.algorithm || input.config.encryption?.advanced?.algorithm,
+    partialEncryption: queryProfile?.partialEncryption || input.config.encryption?.advanced?.partialEncryption
+  });
+  if (!profile.password) {
+    throw new Error(`Missing encryption password for ${input.clientPath}`);
+  }
+  return profile;
+}
+var DownloadDecryptTransform = class extends import_node_stream.Transform {
+  constructor(encryptor, startOffset, encryptedBytes) {
+    super();
+    this.encryptor = encryptor;
+    this.encryptedBytes = encryptedBytes;
+    this.offset = startOffset;
+  }
+  offset;
+  async _transform(chunk, _encoding, callback) {
+    try {
+      const chunkStart = this.offset;
+      const chunkEnd = chunkStart + chunk.length;
+      if (chunkStart >= this.encryptedBytes) {
+        this.offset += chunk.length;
+        callback(null, chunk);
+        return;
+      }
+      if (chunkEnd <= this.encryptedBytes) {
+        const decrypted2 = await this.encryptor.decryptChunk(
+          new Uint8Array(chunk),
+          this.offset
+        );
+        this.offset += chunk.length;
+        callback(null, Buffer.from(decrypted2));
+        return;
+      }
+      const encryptedPartLength = this.encryptedBytes - chunkStart;
+      const encryptedPart = chunk.slice(0, encryptedPartLength);
+      const plainPart = chunk.slice(encryptedPartLength);
+      const decrypted = await this.encryptor.decryptChunk(
+        new Uint8Array(encryptedPart),
+        this.offset
+      );
+      this.offset += chunk.length;
+      callback(null, Buffer.concat([Buffer.from(decrypted), plainPart]));
+    } catch (error) {
+      callback(toFileSystemError(error));
+    }
+  }
+};
+function isUploadHandle(value) {
+  return Boolean(
+    value && typeof value === "object" && "upload" in value && typeof value.upload === "function"
+  );
+}
+async function syncUploadedFileCache(volume, parentPath, fileName, uploadResult) {
+  const cache = volume?._fs?.cache;
+  const fsAdapter = volume?._fs;
+  if (!cache || !fsAdapter) {
+    return;
+  }
+  const targetPath = normalizeFtpClientPath(
+    import_node_path2.default.posix.join(parentPath, fileName)
+  );
+  try {
+    if (uploadResult) {
+      await cache.handleOperation({
+        type: "create",
+        path: targetPath,
+        parentPath,
+        newItem: uploadResult,
+        fs: fsAdapter
+      });
+      return;
+    }
+  } catch {
+  }
+  if (typeof cache.markForRefresh === "function") {
+    await cache.markForRefresh(parentPath);
+    await cache.markForRefresh(targetPath);
+    return;
+  }
+  if (typeof volume.refresh === "function") {
+    await volume.refresh(parentPath);
+    await volume.refresh(targetPath);
+  }
+}
+var DeferredUploadWriteStream = class extends import_node_stream.Writable {
+  constructor(volume, relativePath, tempFilePath, runtime) {
+    super();
+    this.volume = volume;
+    this.relativePath = relativePath;
+    this.tempFilePath = tempFilePath;
+    this.runtime = runtime;
+    this.localStream = import_node_fs.default.createWriteStream(this.tempFilePath, { flags: "w" });
+  }
+  localStream;
+  commitPromise = null;
+  tempFileRemoved = false;
+  _write(chunk, encoding, callback) {
+    this.localStream.write(chunk, encoding, callback);
+  }
+  _final(callback) {
+    this.localStream.end(() => {
+      this.commitPromise = this.commitUploadedFile();
+      this.commitPromise.then(() => callback()).catch((error) => callback(toFileSystemError(error))).finally(() => {
+        this.cleanupTempFile();
+      });
+    });
+  }
+  _destroy(error, callback) {
+    if (this.commitPromise) {
+      callback(error);
+      return;
+    }
+    if (!this.localStream.destroyed) {
+      this.localStream.destroy();
+    }
+    this.cleanupTempFile();
+    callback(error);
+  }
+  async commitUploadedFile() {
+    const parentPath = import_node_path2.default.posix.dirname(this.relativePath);
+    let fileName = import_node_path2.default.posix.basename(this.relativePath);
+    let uploadFilePath = this.tempFilePath;
+    if (this.runtime.crypto.isContentEncryptionEnabled()) {
+      const contentProfile = this.runtime.crypto.resolveProfile();
+      if (!contentProfile.password) {
+        throw new Error(`Missing encryption password for ${this.relativePath}`);
+      }
+      const encryptedTempFilePath = `${this.tempFilePath}.enc`;
+      const encryptor = await this.runtime.crypto.createFileEncryptor();
+      await encryptLocalFileWithEncryptor(
+        this.tempFilePath,
+        encryptedTempFilePath,
+        encryptor
+      );
+      uploadFilePath = encryptedTempFilePath;
+      fileName = (0, import_runtime.addContentEncryptionSuffix)(fileName);
+    }
+    const fileMetadata = createUploadFileMetadata(
+      uploadFilePath,
+      fileName,
+      this.runtime.workspaceRoot
+    );
+    const uploadController = typeof this.volume?.createUpload === "function" ? await this.volume.createUpload(parentPath, fileMetadata) : await this.volume.upload(parentPath, fileMetadata);
+    const uploadResult = isUploadHandle(uploadController) ? await uploadController.upload() : uploadController;
+    await syncUploadedFileCache(
+      this.volume,
+      parentPath,
+      fileName,
+      uploadResult
+    );
+    if (uploadFilePath !== this.tempFilePath && import_node_fs.default.existsSync(uploadFilePath)) {
+      import_node_fs.default.unlinkSync(uploadFilePath);
+    }
+  }
+  cleanupTempFile() {
+    if (this.tempFileRemoved) {
+      return;
+    }
+    this.tempFileRemoved = true;
+    try {
+      if (import_node_fs.default.existsSync(this.tempFilePath)) {
+        import_node_fs.default.unlinkSync(this.tempFilePath);
+      }
+    } catch {
+    }
+  }
+};
+async function encryptLocalFileWithEncryptor(inputPath, outputPath, encryptor) {
+  const chunkSize = 1024 * 1024;
+  const fileSize = import_node_fs.default.statSync(inputPath).size;
+  const inputFd = import_node_fs.default.openSync(inputPath, "r");
+  const outputFd = import_node_fs.default.openSync(outputPath, "w");
+  try {
+    let offset = 0;
+    const buffer = Buffer.allocUnsafe(chunkSize);
+    while (offset < fileSize) {
+      const bytesToRead = Math.min(chunkSize, fileSize - offset);
+      const bytesRead = import_node_fs.default.readSync(inputFd, buffer, 0, bytesToRead, offset);
+      if (bytesRead === 0) {
+        break;
+      }
+      const chunk = new Uint8Array(buffer.buffer, buffer.byteOffset, bytesRead);
+      const encryptedChunk = await encryptor.encryptChunk(chunk, offset);
+      import_node_fs.default.writeSync(outputFd, Buffer.from(encryptedChunk));
+      offset += bytesRead;
+    }
+  } finally {
+    import_node_fs.default.closeSync(inputFd);
+    import_node_fs.default.closeSync(outputFd);
+  }
+}
+var FileBoxFtpFileSystem = class extends import_ftp_srv2.FileSystem {
+  constructor(connection, runtime) {
+    super(connection, { root: "/", cwd: "/" });
+    this.runtime = runtime;
+  }
+  cryptPromise;
+  resolveClientPath(targetPath = ".") {
+    return resolveFtpClientReference(this.currentDirectory(), targetPath);
+  }
+  getApp() {
+    return this.runtime.app;
+  }
+  getCrypt() {
+    if (this.cryptPromise) {
+      return this.cryptPromise;
+    }
+    this.cryptPromise = (async () => {
+      if (!this.runtime.config.encryption?.password) {
+        return null;
+      }
+      return this.runtime.crypto.createFsCrypt();
+    })();
+    return this.cryptPromise;
+  }
+  async getDisplayName(rawName) {
+    const crypt = await this.getCrypt();
+    if (!crypt || !rawName) {
+      return rawName;
+    }
+    if (!await crypt.isEncrypted(rawName)) {
+      return rawName;
+    }
+    const decryptedName = await crypt.decryptFilename(rawName);
+    return decryptedName || rawName;
+  }
+  async decorateRemoteItem(item) {
+    const displayName = await this.getDisplayName(item?.name || "");
+    if (!displayName || displayName === item?.name) {
+      return item;
+    }
+    return {
+      ...item,
+      name: displayName,
+      original_name: displayName
+    };
+  }
+  async transformStoredName(name) {
+    if (!this.runtime.crypto.isFilenameEncryptionEnabled()) {
+      return name;
+    }
+    const crypt = await this.getCrypt();
+    if (!crypt) {
+      return name;
+    }
+    return crypt.encryptFilename(name);
+  }
+  splitMountedPath(clientPath) {
+    const normalizedPath = normalizeFtpClientPath(clientPath);
+    const segments = normalizedPath.split("/").filter(Boolean);
+    const mountName = segments[0] || "";
+    const relativePath = segments.length > 1 ? `/${segments.slice(1).join("/")}` : "/";
+    return {
+      normalizedPath,
+      mountName,
+      relativePath: normalizeFtpClientPath(relativePath)
+    };
+  }
+  getMountedVolume(clientPath) {
+    const { normalizedPath, mountName, relativePath } = this.splitMountedPath(clientPath);
+    if (normalizedPath === "/") {
+      return {
+        mountName: "",
+        relativePath: "/",
+        volume: null
+      };
+    }
+    const app = this.getApp();
+    const volume = app.getVolume?.(mountName) || app.getVolume?.(`/${mountName}`) || app.volumeMap?.get?.(mountName) || app.volumeMap?.get?.(`/${mountName}`);
+    if (!volume) {
+      throw new Error(`Drive "${mountName}" is not mounted`);
+    }
+    return {
+      mountName,
+      relativePath,
+      volume
+    };
+  }
+  async findRemoteEntryByClientName(items, clientName) {
+    for (const item of items) {
+      if (item?.name === clientName) {
+        return item;
+      }
+      if (await this.getDisplayName(item?.name || "") === clientName) {
+        return item;
+      }
+    }
+    return null;
+  }
+  async resolveExistingMountedPath(clientPath) {
+    const mounted = this.getMountedVolume(clientPath);
+    if (!mounted.volume || mounted.relativePath === "/") {
+      return mounted;
+    }
+    const segments = mounted.relativePath.split("/").filter(Boolean);
+    let resolvedPath = "/";
+    for (const segment of segments) {
+      const listing = await mounted.volume.list(resolvedPath);
+      const items = Array.isArray(listing?.data) ? listing.data : [];
+      const matchedEntry = await this.findRemoteEntryByClientName(
+        items,
+        segment
+      );
+      if (!matchedEntry?.name) {
+        resolvedPath = normalizeFtpClientPath(
+          import_node_path2.default.posix.join(resolvedPath, segment)
+        );
+        continue;
+      }
+      resolvedPath = normalizeFtpClientPath(
+        import_node_path2.default.posix.join(resolvedPath, matchedEntry.name)
+      );
+    }
+    return {
+      ...mounted,
+      relativePath: resolvedPath
+    };
+  }
+  async getRootEntry(mountName) {
+    const result = await this.getApp().list("/");
+    const items = Array.isArray(result) ? result : result?.data || [];
+    const entry = items.find((item) => item?.name === mountName);
+    if (!entry) {
+      throw new Error(`Drive "${mountName}" is not mounted`);
+    }
+    return entry;
+  }
+  createTempFilePath() {
+    const tempRoot = this.runtime.config.tempPath;
+    return import_node_path2.default.join(
+      tempRoot,
+      `ftp-upload-${Date.now()}-${Math.random().toString(36).slice(2)}.tmp`
+    );
+  }
+  async get(fileName) {
+    try {
+      const clientPath = this.resolveClientPath(fileName);
+      if (clientPath === "/") {
+        return toFileEntry(await this.getApp().stat("/"));
+      }
+      const { mountName, relativePath, volume } = await this.resolveExistingMountedPath(clientPath);
+      const stat = relativePath === "/" ? await this.getRootEntry(mountName) : await volume.stat(relativePath);
+      return toFileEntry(await this.decorateRemoteItem(stat));
+    } catch (error) {
+      throw toFileSystemError(error);
+    }
+  }
+  async list(targetPath = ".") {
+    try {
+      const clientPath = this.resolveClientPath(targetPath);
+      const mounted = clientPath === "/" ? null : await this.resolveExistingMountedPath(clientPath);
+      const result = mounted ? await mounted.volume.list(mounted.relativePath) : await this.getApp().list("/");
+      const items = Array.isArray(result) ? result : result?.data || [];
+      const decoratedItems = await Promise.all(
+        items.map((item) => this.decorateRemoteItem(item))
+      );
+      return decoratedItems.map((item) => toFileEntry(item));
+    } catch (error) {
+      throw toFileSystemError(error);
+    }
+  }
+  async chdir(targetPath = ".") {
+    try {
+      const clientPath = this.resolveClientPath(targetPath);
+      const mounted = clientPath === "/" ? null : await this.resolveExistingMountedPath(clientPath);
+      const stat = clientPath === "/" ? await this.getApp().stat("/") : mounted.relativePath === "/" ? await this.getRootEntry(mounted.mountName) : await mounted.volume.stat(mounted.relativePath);
+      if (stat?.type !== "folder" && stat?.directory !== true) {
+        throw new Error("Not a valid directory");
+      }
+      this.cwd = clientPath;
+      return this.currentDirectory();
+    } catch (error) {
+      throw toFileSystemError(error);
+    }
+  }
+  async read(fileName, options = {}) {
+    try {
+      const clientPath = this.resolveClientPath(fileName);
+      const { relativePath, volume } = await this.resolveExistingMountedPath(clientPath);
+      const stat = await volume.stat(relativePath);
+      if (stat?.type === "folder" || stat?.directory === true) {
+        throw new Error("Cannot read a directory");
+      }
+      const [downloadInfo] = await volume.download(relativePath);
+      if (!downloadInfo?.url) {
+        throw new Error("Download URL is not available");
+      }
+      const decryptProfile = resolveFtpDownloadDecryption({
+        clientPath,
+        downloadInfo,
+        config: this.runtime.config
+      });
+      const startOffset = typeof options.start === "number" ? options.start : 0;
+      const localDownloadPath = resolveReadableDownloadPath(downloadInfo.url);
+      if (localDownloadPath) {
+        const sourceStream2 = import_node_fs.default.createReadStream(localDownloadPath, {
+          start: typeof options.start === "number" ? options.start : void 0
+        });
+        if (!decryptProfile) {
+          return {
+            stream: sourceStream2,
+            clientPath
+          };
+        }
+        const totalSize2 = import_node_fs.default.statSync(localDownloadPath).size;
+        const encryptedBytes2 = (0, import_runtime.calculateEncryptedBytes)(
+          totalSize2,
+          decryptProfile.partialEncryption
+        );
+        const encryptor2 = await (0, import_runtime.createFileEncryptor)(decryptProfile);
+        return {
+          stream: sourceStream2.pipe(
+            new DownloadDecryptTransform(
+              encryptor2,
+              startOffset,
+              encryptedBytes2
+            )
+          ),
+          clientPath
+        };
+      }
+      const headers = { ...downloadInfo.headers || {} };
+      if (typeof options.start === "number" && options.start > 0 && !("Range" in headers) && !("range" in headers)) {
+        headers.Range = `bytes=${options.start}-`;
+      }
+      const response = await fetch(downloadInfo.url, { headers });
+      if (!response.ok && response.status !== 206) {
+        throw new Error(
+          `Failed to fetch remote file: ${response.status} ${response.statusText}`
+        );
+      }
+      if (!response.body) {
+        throw new Error("Remote response does not contain a readable body");
+      }
+      const totalSize = parseRemoteResponseTotalSize(response, stat?.byte);
+      const sourceStream = import_node_stream.Readable.fromWeb(response.body);
+      if (!decryptProfile) {
+        return {
+          stream: sourceStream,
+          clientPath
+        };
+      }
+      const encryptedBytes = (0, import_runtime.calculateEncryptedBytes)(
+        totalSize,
+        decryptProfile.partialEncryption
+      );
+      const encryptor = await (0, import_runtime.createFileEncryptor)(decryptProfile);
+      return {
+        stream: sourceStream.pipe(
+          new DownloadDecryptTransform(encryptor, startOffset, encryptedBytes)
+        ),
+        clientPath
+      };
+    } catch (error) {
+      throw toFileSystemError(error);
+    }
+  }
+  async write(fileName, options = {}) {
+    const { append = false, start } = options;
+    if (append || typeof start === "number") {
+      throw new Error("Append and ranged uploads are not supported");
+    }
+    const clientPath = this.resolveClientPath(fileName);
+    const mounted = this.getMountedVolume(clientPath);
+    const parentClientPath = normalizeFtpClientPath(
+      import_node_path2.default.posix.dirname(clientPath)
+    );
+    const parentMounted = parentClientPath === "/" ? mounted : await this.resolveExistingMountedPath(parentClientPath);
+    const relativePath = normalizeFtpClientPath(
+      import_node_path2.default.posix.join(
+        parentMounted.relativePath,
+        await this.transformStoredName(
+          import_node_path2.default.posix.basename(mounted.relativePath)
+        )
+      )
+    );
+    const { volume } = mounted;
+    const stream = new DeferredUploadWriteStream(
+      volume,
+      relativePath,
+      this.createTempFilePath(),
+      this.runtime
+    );
+    return {
+      stream,
+      clientPath
+    };
+  }
+  async delete(targetPath) {
+    try {
+      const clientPath = this.resolveClientPath(targetPath);
+      if (clientPath === "/") {
+        throw new Error("Cannot delete root directory");
+      }
+      const { relativePath, volume } = await this.resolveExistingMountedPath(clientPath);
+      return await volume.remove(relativePath);
+    } catch (error) {
+      throw toFileSystemError(error);
+    }
+  }
+  async mkdir(targetPath) {
+    try {
+      const clientPath = this.resolveClientPath(targetPath);
+      const mounted = this.getMountedVolume(clientPath);
+      const parentClientPath = normalizeFtpClientPath(
+        import_node_path2.default.posix.dirname(clientPath)
+      );
+      const parentMounted = parentClientPath === "/" ? mounted : await this.resolveExistingMountedPath(parentClientPath);
+      const relativePath = normalizeFtpClientPath(
+        import_node_path2.default.posix.join(
+          parentMounted.relativePath,
+          await this.transformStoredName(
+            import_node_path2.default.posix.basename(mounted.relativePath)
+          )
+        )
+      );
+      const { volume } = mounted;
+      return await volume.mkdir(relativePath, {});
+    } catch (error) {
+      throw toFileSystemError(error);
+    }
+  }
+  async rename(from, to) {
+    try {
+      const fromPath = this.resolveClientPath(from);
+      const toPath = this.resolveClientPath(to);
+      const fromMounted = await this.resolveExistingMountedPath(fromPath);
+      const toMounted = this.getMountedVolume(toPath);
+      if (fromMounted.mountName !== toMounted.mountName) {
+        throw new Error("Cross-drive rename is not supported");
+      }
+      const fromDir = import_node_path2.default.posix.dirname(fromMounted.relativePath);
+      const toDirClientPath = normalizeFtpClientPath(
+        import_node_path2.default.posix.dirname(toPath)
+      );
+      const resolvedToParent = toDirClientPath === "/" ? toMounted : await this.resolveExistingMountedPath(toDirClientPath);
+      const toDir = resolvedToParent.relativePath;
+      const targetRelativePath = normalizeFtpClientPath(
+        import_node_path2.default.posix.join(
+          resolvedToParent.relativePath,
+          await this.transformStoredName(
+            import_node_path2.default.posix.basename(toMounted.relativePath)
+          )
+        )
+      );
+      if (fromDir === toDir) {
+        return await fromMounted.volume.rename(
+          fromMounted.relativePath,
+          import_node_path2.default.posix.basename(targetRelativePath)
+        );
+      }
+      if (typeof fromMounted.volume.move !== "function") {
+        throw new Error("Move is not supported by this drive");
+      }
+      return await fromMounted.volume.move(
+        fromMounted.relativePath,
+        targetRelativePath
+      );
+    } catch (error) {
+      throw toFileSystemError(error);
+    }
+  }
+};
+
+// src/adapters/filebox/runtime.ts
+function resolveMountedDriveNames(app, mountedDriveNames) {
+  if (mountedDriveNames && mountedDriveNames.length > 0) {
+    return mountedDriveNames;
+  }
+  const volumeMap = app?.volumeMap;
+  if (!(volumeMap instanceof Map)) {
+    return [];
+  }
+  return Array.from(volumeMap.values()).map((volume) => volume?._options?.name || volume?.name || "").map((name) => String(name || "").replace(/^\/+/, "")).filter(Boolean);
+}
+function createRuntime(options) {
+  if (!options.runtime) {
+    throw new Error("createRuntime requires a runtime instance.");
+  }
+  return Object.assign(options.runtime, {
+    mountedDriveNames: resolveMountedDriveNames(
+      options.runtime.app,
+      options.mountedDriveNames
+    )
+  });
+}
+
+// src/adapters/filebox/session.ts
+function createFileBoxFtpSessionFactory(runtime) {
+  return async () => ({
+    root: "/",
+    fs: new FileBoxFtpFileSystem(void 0, runtime)
+  });
+}
+
+// src/adapters/workspace/index.ts
+var import_runtime3 = require("@filebox/runtime");
+async function mountEnabledDrives(runtime, options = {}) {
+  const onlyDrive = options.onlyDrive?.trim();
+  const drives = await runtime.drives.list();
+  const mountedNames = [];
+  for (const drive of drives) {
+    if (!drive.enabled) {
+      continue;
+    }
+    if (onlyDrive && drive.name !== onlyDrive) {
+      continue;
+    }
+    if (!drive.supported) {
+      console.warn(
+        `[ftp-server] Skip drive "${drive.name}": provider "${drive.provider}" is not loaded.`
+      );
+      continue;
+    }
+    if (!drive.ready) {
+      console.warn(
+        `[ftp-server] Skip drive "${drive.name}": ${drive.issue || "configuration is incomplete."}`
+      );
+      continue;
+    }
+    try {
+      await runtime.app.mount(drive);
+      mountedNames.push(drive.name);
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      console.warn(
+        `[ftp-server] Failed to mount drive "${drive.name}": ${message}`
+      );
+    }
+  }
+  return mountedNames;
+}
+async function createWorkspaceRuntime(options = {}) {
+  const { configPath, config } = (0, import_runtime3.loadWorkspaceConfigInput)({
+    workspaceRoot: options.workspaceRoot || null
+  });
+  const runtime = await import_runtime3.FileBoxRuntime.create({
+    configPath,
+    config
+  });
+  const mountedDriveNames = await mountEnabledDrives(runtime, options);
+  return Object.assign(runtime, {
+    mountedDriveNames
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FileBoxFtpFileSystem,
+  FileBoxFtpServer,
+  createFileBoxFtpSessionFactory,
+  createRuntime,
+  createStaticFtpAuthenticator,
+  createWorkspaceRuntime,
+  normalizeServerCredentials
+});

package/package.json

@@ -1,23 +1,21 @@
 {
   "name": "@filebox/ftp-server",
-  "version": "1.0.0",
-  "description": "FTP server library for FileBox.",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "default": "./dist/index.js"
-    }
-  },
-  "files": [
-    "dist/index.js",
-    "dist/**/*.d.ts",
-    "LICENSE",
-    "CHANGELOG.md",
-    "README.md"
+  "version": "1.0.1",
+  "description": "FTP server library for FileBox.",
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.mjs"
+    }
+  },
+  "files": [
+    "dist"
   ],
   "publishConfig": {
     "access": "public"
@@ -27,20 +25,20 @@
     "ftp",
     "ftp-server"
   ],
-  "license": "MIT",
-  "scripts": {
-    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --target=node18 --packages=external --outfile=dist/index.js && tsc -p tsconfig.json --emitDeclarationOnly",
-    "prepack": "esbuild src/index.ts --bundle --platform=node --format=esm --target=node18 --packages=external --outfile=dist/index.js && tsc -p tsconfig.json --emitDeclarationOnly",
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  },
-  "dependencies": {
-    "@filebox/runtime": "^1.0.0",
-    "ftp-srv": "^4.6.3"
-  },
-  "devDependencies": {
-    "@types/node": "^24.0.13",
-    "esbuild": "^0.24.0",
-    "tsx": "^4.20.5",
-    "typescript": "^5.5.4"
-  }
-}
+  "license": "MIT",
+  "scripts": {
+    "build": "node build.mjs",
+    "prepack": "node build.mjs",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
+  },
+  "dependencies": {
+    "@filebox/runtime": "^1.0.0",
+    "ftp-srv": "^4.6.3"
+  },
+  "devDependencies": {
+    "@types/node": "^24.0.13",
+    "esbuild": "^0.24.0",
+    "tsx": "^4.20.5",
+    "typescript": "^5.5.4"
+  }
+}

package/CHANGELOG.md

@@ -1,2 +0,0 @@
-# Changelog
-