@filebox/s3-server 1.0.0 → 1.0.1

package/dist/index.cjs

@@ -0,0 +1,1372 @@
+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, {
+  default: () => S3Server
+});
+module.exports = __toCommonJS(index_exports);
+var import_body_parser = __toESM(require("body-parser"), 1);
+var import_express = __toESM(require("express"), 1);
+var import_http = __toESM(require("http"), 1);
+var import_https = __toESM(require("https"), 1);
+
+// src/context.ts
+var createContext = (req) => {
+  const authorization = req.headers?.authorization?.split(" ")[1];
+  const url = new URL(req.url, `http://${req.headers.host}`);
+  const path4 = url.pathname;
+  const query = {};
+  url.searchParams.forEach((value, key) => {
+    query[key] = value;
+  });
+  const ctx = {
+    req,
+    method: (req.method || "").toLowerCase(),
+    path: path4,
+    query,
+    auth: { accessKeyId: void 0, secretAccessKey: void 0 },
+    // 获取请求头
+    get(field) {
+      const req2 = this.req;
+      switch (field = field.toLowerCase()) {
+        case "referer":
+        case "referrer":
+          return req2.headers.referrer || req2.headers.referer || "";
+        default:
+          return req2.headers[field] || "";
+      }
+    },
+    // 解析S3请求参数
+    getBucketAndKey() {
+      const parts = this.path.split("/").filter(Boolean);
+      const bucket = parts[0];
+      const key = parts.slice(1).join("/");
+      return { bucket, key };
+    }
+  };
+  if (authorization) {
+    try {
+      const decoded = Buffer.from(authorization, "base64").toString("utf8");
+      const [accessKeyId, secretAccessKey] = decoded.split(":");
+      ctx.auth = { accessKeyId, secretAccessKey };
+    } catch (error) {
+    }
+  }
+  return ctx;
+};
+var context_default = createContext;
+
+// src/responses.ts
+var import_crypto = __toESM(require("crypto"), 1);
+var import_xml2js = require("xml2js");
+var Responses = class {
+  constructor() {
+    this.xmlBuilder = new import_xml2js.Builder({
+      xmldec: {
+        version: "1.0",
+        encoding: "utf-8"
+      }
+    });
+  }
+  /**
+   * 发送XML响应
+   * @param {object} res - Express响应对象
+   * @param {object} xmlObject - 要转换为XML的对象
+   * @param {number} status - HTTP状态码
+   */
+  async sendXmlResponse(res, xmlObject, status = 200) {
+    if (res.headersSent) {
+      return;
+    }
+    const response = this.xmlBuilder.buildObject(xmlObject);
+    res.set("Content-Type", "application/xml; charset=utf-8");
+    res.set("Content-Length", Buffer.byteLength(response).toString());
+    res.set("Date", (/* @__PURE__ */ new Date()).toUTCString());
+    res.status(status);
+    return new Promise((resolve) => {
+      res.end(response, () => {
+        resolve();
+      });
+    });
+  }
+  /**
+   * 发送错误响应
+   * @param {object} res - Express响应对象
+   * @param {number} status - HTTP状态码
+   * @param {string} code - 错误代码
+   * @param {string} message - 错误消息
+   */
+  async error(res, status, code, message) {
+    return this.sendXmlResponse(
+      res,
+      {
+        Error: {
+          Code: code,
+          Message: message
+        }
+      },
+      status
+    );
+  }
+  /**
+   * 列出所有存储桶
+   * @param {object} res - Express响应对象
+   * @param {Array} buckets - 存储桶列表
+   * @param {object} owner - 所有者信息
+   */
+  async listBuckets(res, buckets, owner) {
+    return this.sendXmlResponse(res, {
+      ListAllMyBucketsResult: {
+        $: { xmlns: "http://s3.amazonaws.com/doc/2006-03-01/" },
+        Buckets: {
+          Bucket: buckets.map((bucket) => ({
+            CreationDate: new Date(bucket.creationDate).toISOString(),
+            Name: bucket.name
+          }))
+        },
+        Owner: {
+          ID: import_crypto.default.createHash("sha256").update(owner.id).digest("hex"),
+          DisplayName: owner.displayName || ""
+        }
+      }
+    });
+  }
+  /**
+   * 列出对象(V2)
+   * @param {object} res - Express响应对象
+   * @param {string} prefix - 前缀
+   * @param {Array} objects - 对象列表
+   * @param {Array} commonPrefixes - 公共前缀
+   * @param {string} bucket - 存储桶名称
+   * @param {string} delimiter - 分隔符
+   */
+  async listObjectsV2(res, prefix, objects, commonPrefixes, bucket, delimiter) {
+    return this.sendXmlResponse(res, {
+      ListBucketResult: {
+        IsTruncated: false,
+        Contents: objects.map((object) => ({
+          Key: object.path,
+          LastModified: new Date(object.mtimeMs).toISOString(),
+          Size: object.size.toString(),
+          ETag: `"${object.uuid || import_crypto.default.randomUUID()}"`,
+          StorageClass: "STANDARD"
+        })),
+        CommonPrefixes: commonPrefixes.map((prefix2) => ({
+          Prefix: prefix2
+        })),
+        KeyCount: objects.length.toString(),
+        Prefix: prefix,
+        Delimiter: delimiter,
+        MaxKeys: 1e3,
+        Name: bucket
+      }
+    });
+  }
+  /**
+   * 删除对象响应
+   * @param {object} res - Express响应对象
+   * @param {Array} deleted - 已删除的对象
+   * @param {Array} errors - 错误信息
+   */
+  async deleteObjects(res, deleted, errors) {
+    return this.sendXmlResponse(res, {
+      DeleteResult: {
+        Deleted: deleted.map((del) => ({
+          Key: del.Key
+        })),
+        Error: errors.map((error) => ({
+          Key: error.Key,
+          Code: error.Code,
+          Message: error.Message
+        }))
+      }
+    });
+  }
+  /**
+   * 获取存储桶位置
+   * @param {object} res - Express响应对象
+   * @param {string} region - 区域
+   */
+  async getBucketLocation(res, region) {
+    return this.sendXmlResponse(res, {
+      LocationConstraint: region || ""
+    });
+  }
+  /**
+   * 成功响应(200 OK)
+   * @param {object} res - Express响应对象
+   */
+  async ok(res) {
+    if (res.headersSent) {
+      return;
+    }
+    res.set("Content-Type", "application/xml; charset=utf-8");
+    res.set("Content-Length", "0");
+    res.set("Date", (/* @__PURE__ */ new Date()).toUTCString());
+    res.status(200);
+    return new Promise((resolve) => {
+      res.end("", () => {
+        resolve();
+      });
+    });
+  }
+  /**
+   * 无内容响应(204 No Content)
+   * @param {object} res - Express响应对象
+   */
+  async noContent(res) {
+    if (res.headersSent) {
+      return;
+    }
+    res.set("Content-Type", "application/xml; charset=utf-8");
+    res.set("Content-Length", "0");
+    res.set("Date", (/* @__PURE__ */ new Date()).toUTCString());
+    res.status(204);
+    return new Promise((resolve) => {
+      res.end("", () => {
+        resolve();
+      });
+    });
+  }
+};
+var responses_default = new Responses();
+
+// src/handlers/createBucket.ts
+var CreateBucket = class {
+  constructor(server) {
+    this.server = server;
+    this.handle = this.handle.bind(this);
+  }
+  /**
+   * 处理CreateBucket请求
+   * @param {object} req - Express请求对象
+   * @param {object} res - Express响应对象
+   */
+  async handle(req, res) {
+    try {
+      const { bucket } = this.extractBucketAndKey(req);
+      if (!bucket) {
+        await responses_default.error(
+          res,
+          400,
+          "InvalidBucketName",
+          "\u65E0\u6548\u7684\u5B58\u50A8\u6876\u540D\u79F0"
+        );
+        return;
+      }
+      if (!this.isValidBucketName(bucket)) {
+        await responses_default.error(
+          res,
+          400,
+          "InvalidBucketName",
+          "\u5B58\u50A8\u6876\u540D\u79F0\u4E0D\u7B26\u5408\u89C4\u8303"
+        );
+        return;
+      }
+      const bucketExists = await this.server.driver.bucketExists(bucket);
+      if (bucketExists) {
+        if (await this.server.driver.isBucketOwner(bucket)) {
+          res.set("Location", `/${bucket}`);
+          await responses_default.ok(res);
+          return;
+        }
+        await responses_default.error(
+          res,
+          409,
+          "BucketAlreadyExists",
+          "\u5B58\u50A8\u6876\u5DF2\u5B58\u5728\u4E14\u4E0D\u5C5E\u4E8E\u60A8"
+        );
+        return;
+      }
+      await this.server.driver.createBucket(bucket);
+      res.set("Location", `/${bucket}`);
+      await responses_default.ok(res);
+    } catch (error) {
+      console.error("Error in CreateBucket:", error);
+      await responses_default.error(res, 500, "InternalError", "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF");
+    }
+  }
+  /**
+   * 从请求参数中提取存储桶和键
+   * @param {object} req - Express请求对象
+   * @returns {object} 包含存储桶和键的对象
+   */
+  extractBucketAndKey(req) {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    return {
+      bucket: pathParts[0],
+      key: pathParts.slice(1).join("/")
+    };
+  }
+  /**
+   * 验证存储桶名称是否符合规范
+   * @param {string} name - 存储桶名称
+   * @returns {boolean} 是否有效
+   */
+  isValidBucketName(name) {
+    if (!name || name.length < 3 || name.length > 63) {
+      return false;
+    }
+    if (!/^[a-z0-9][a-z0-9.-]*[a-z0-9]$/.test(name)) {
+      return false;
+    }
+    if (/^\d+\.\d+\.\d+\.\d+$/.test(name)) {
+      return false;
+    }
+    if (name.includes("..") || name.includes(".-") || name.includes("-.")) {
+      return false;
+    }
+    return true;
+  }
+};
+
+// src/handlers/deleteBucket.ts
+var DeleteBucket = class {
+  constructor(server) {
+    this.server = server;
+    this.handle = this.handle.bind(this);
+  }
+  /**
+   * 处理DeleteBucket请求
+   * @param {object} req - Express请求对象
+   * @param {object} res - Express响应对象
+   */
+  async handle(req, res) {
+    try {
+      const { bucket } = this.extractBucketAndKey(req);
+      if (!bucket) {
+        await responses_default.error(
+          res,
+          400,
+          "InvalidBucketName",
+          "\u65E0\u6548\u7684\u5B58\u50A8\u6876\u540D\u79F0"
+        );
+        return;
+      }
+      const bucketExists = await this.server.driver.bucketExists(bucket);
+      if (!bucketExists) {
+        await responses_default.error(res, 404, "NoSuchBucket", "\u5B58\u50A8\u6876\u4E0D\u5B58\u5728");
+        return;
+      }
+      const isEmpty = await this.server.driver.isBucketEmpty(bucket);
+      if (!isEmpty) {
+        await responses_default.error(res, 409, "BucketNotEmpty", "\u5B58\u50A8\u6876\u4E0D\u4E3A\u7A7A");
+        return;
+      }
+      const isOwner = await this.server.driver.isBucketOwner(bucket);
+      if (!isOwner) {
+        await responses_default.error(res, 403, "AccessDenied", "\u6CA1\u6709\u6743\u9650\u5220\u9664\u6B64\u5B58\u50A8\u6876");
+        return;
+      }
+      await this.server.driver.deleteBucket(bucket);
+      await responses_default.noContent(res);
+    } catch (error) {
+      console.error("Error in DeleteBucket:", error);
+      await responses_default.error(res, 500, "InternalError", "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF");
+    }
+  }
+  /**
+   * 从请求参数中提取存储桶和键
+   * @param {object} req - Express请求对象
+   * @returns {object} 包含存储桶和键的对象
+   */
+  extractBucketAndKey(req) {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    return {
+      bucket: pathParts[0],
+      key: pathParts.slice(1).join("/")
+    };
+  }
+};
+
+// src/handlers/deleteObject.ts
+var DeleteObject = class {
+  constructor(server) {
+    this.server = server;
+    this.handle = this.handle.bind(this);
+  }
+  /**
+   * 处理DeleteObject请求
+   * @param {object} req - Express请求对象
+   * @param {object} res - Express响应对象
+   */
+  async handle(req, res) {
+    try {
+      const { bucket, key } = this.extractBucketAndKey(req);
+      if (!bucket) {
+        await responses_default.error(res, 404, "NoSuchBucket", "\u5B58\u50A8\u6876\u4E0D\u5B58\u5728");
+        return;
+      }
+      if (!key) {
+        await responses_default.error(res, 400, "InvalidRequest", "\u65E0\u6548\u7684\u5BF9\u8C61\u952E");
+        return;
+      }
+      const objectPath = `/${bucket}/${key}`;
+      const stats = await this.server.driver.stat(objectPath);
+      if (!stats) {
+        await responses_default.noContent(res);
+        return;
+      }
+      if (stats.isDirectory) {
+        await responses_default.error(res, 400, "InvalidRequest", "\u8BF7\u6C42\u7684\u952E\u662F\u4E00\u4E2A\u76EE\u5F55");
+        return;
+      }
+      await this.server.driver.unlink(objectPath);
+      await responses_default.noContent(res);
+    } catch (error) {
+      console.error("Error in DeleteObject:", error);
+      await responses_default.error(res, 500, "InternalError", "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF");
+    }
+  }
+  /**
+   * 从请求参数中提取存储桶和键
+   * @param {object} req - Express请求对象
+   * @returns {object} 包含存储桶和键的对象
+   */
+  extractBucketAndKey(req) {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    return {
+      bucket: pathParts[0],
+      key: pathParts.slice(1).join("/")
+    };
+  }
+};
+
+// src/handlers/deleteObjects.ts
+var import_xml2js2 = require("xml2js");
+var DeleteObjects = class {
+  constructor(server) {
+    this.server = server;
+    this.handle = this.handle.bind(this);
+  }
+  /**
+   * 处理DeleteObjects请求
+   * @param {object} req - Express请求对象
+   * @param {object} res - Express响应对象
+   */
+  async handle(req, res) {
+    try {
+      const { bucket } = this.extractBucketAndKey(req);
+      if (!bucket) {
+        await responses_default.error(res, 404, "NoSuchBucket", "\u5B58\u50A8\u6876\u4E0D\u5B58\u5728");
+        return;
+      }
+      const bucketExists = await this.server.driver.bucketExists(bucket);
+      if (!bucketExists) {
+        await responses_default.error(res, 404, "NoSuchBucket", "\u5B58\u50A8\u6876\u4E0D\u5B58\u5728");
+        return;
+      }
+      const body = await this.getRequestBody(req);
+      let deleteData;
+      try {
+        const parsedXml = await (0, import_xml2js2.parseStringPromise)(body);
+        deleteData = parsedXml.Delete;
+      } catch (error) {
+        await responses_default.error(res, 400, "MalformedXML", "XML\u683C\u5F0F\u9519\u8BEF");
+        return;
+      }
+      if (!deleteData || !deleteData.Object || !Array.isArray(deleteData.Object)) {
+        await responses_default.error(res, 400, "MalformedXML", "\u65E0\u6548\u7684\u5220\u9664\u8BF7\u6C42");
+        return;
+      }
+      const objectsToDelete = deleteData.Object.map((obj) => ({
+        Key: obj.Key[0]
+      }));
+      const deleted = [];
+      const errors = [];
+      for (const obj of objectsToDelete) {
+        try {
+          const objectPath = `/${bucket}/${obj.Key}`;
+          const stats = await this.server.driver.stat(objectPath);
+          if (!stats) {
+            deleted.push({ Key: obj.Key });
+            continue;
+          }
+          if (stats.isDirectory) {
+            errors.push({
+              Key: obj.Key,
+              Code: "InvalidRequest",
+              Message: "\u8BF7\u6C42\u7684\u952E\u662F\u4E00\u4E2A\u76EE\u5F55"
+            });
+            continue;
+          }
+          await this.server.driver.unlink(objectPath);
+          deleted.push({ Key: obj.Key });
+        } catch (error) {
+          errors.push({
+            Key: obj.Key,
+            Code: "InternalError",
+            Message: "\u5220\u9664\u5BF9\u8C61\u65F6\u53D1\u751F\u9519\u8BEF"
+          });
+        }
+      }
+      await responses_default.deleteObjects(res, deleted, errors);
+    } catch (error) {
+      console.error("Error in DeleteObjects:", error);
+      await responses_default.error(res, 500, "InternalError", "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF");
+    }
+  }
+  /**
+   * 从请求参数中提取存储桶和键
+   * @param {object} req - Express请求对象
+   * @returns {object} 包含存储桶和键的对象
+   */
+  extractBucketAndKey(req) {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    return {
+      bucket: pathParts[0],
+      key: pathParts.slice(1).join("/")
+    };
+  }
+  /**
+   * 获取请求体内容
+   * @param {object} req - Express请求对象
+   * @returns {Promise<string>} 请求体内容
+   */
+  getRequestBody(req) {
+    return new Promise((resolve, reject) => {
+      let body = "";
+      req.on("data", (chunk) => {
+        body += chunk.toString();
+      });
+      req.on("end", () => {
+        resolve(body);
+      });
+      req.on("error", (error) => {
+        reject(error);
+      });
+    });
+  }
+};
+
+// src/handlers/getObject.ts
+var import_crypto2 = __toESM(require("crypto"), 1);
+var import_path = __toESM(require("path"), 1);
+var GetObject = class {
+  constructor(server) {
+    this.server = server;
+    this.handle = this.handle.bind(this);
+  }
+  /**
+   * 处理GetObject请求
+   * @param {object} req - Express请求对象
+   * @param {object} res - Express响应对象
+   */
+  async handle(req, res) {
+    try {
+      const { bucket, key } = this.extractBucketAndKey(req);
+      if (!bucket) {
+        await responses_default.error(res, 404, "NoSuchBucket", "\u5B58\u50A8\u6876\u4E0D\u5B58\u5728");
+        return;
+      }
+      if (!key) {
+        await responses_default.error(res, 400, "InvalidRequest", "\u65E0\u6548\u7684\u5BF9\u8C61\u952E");
+        return;
+      }
+      const objectPath = `/${bucket}/${key}`;
+      const stats = await this.server.driver.stat(objectPath);
+      if (!stats) {
+        await responses_default.error(res, 404, "NoSuchKey", "\u5BF9\u8C61\u4E0D\u5B58\u5728");
+        return;
+      }
+      if (stats.isDirectory) {
+        await responses_default.error(res, 400, "InvalidRequest", "\u8BF7\u6C42\u7684\u952E\u662F\u4E00\u4E2A\u76EE\u5F55");
+        return;
+      }
+      res.set("Content-Type", this.getContentType(key));
+      res.set("Content-Length", stats.size.toString());
+      res.set("Last-Modified", new Date(stats.mtime).toUTCString());
+      res.set("ETag", `"${stats.uuid || import_crypto2.default.randomUUID()}"`);
+      res.set("Accept-Ranges", "bytes");
+      res.set("Date", (/* @__PURE__ */ new Date()).toUTCString());
+      if (req.headers.range) {
+        const range2 = this.parseRange(req.headers.range, stats.size);
+        if (range2) {
+          res.set(
+            "Content-Range",
+            `bytes ${range2.start}-${range2.end}/${stats.size}`
+          );
+          res.set("Content-Length", (range2.end - range2.start + 1).toString());
+          res.status(206);
+        } else {
+          res.set("Content-Range", `bytes */${stats.size}`);
+          res.status(416);
+          res.end();
+          return;
+        }
+      } else {
+        res.status(200);
+      }
+      const stream = await this.server.driver.createReadStream(objectPath, {
+        start: range?.start,
+        end: range?.end
+      });
+      stream.pipe(res);
+      stream.on("error", async (error) => {
+        console.error("Error streaming object:", error);
+        if (!res.headersSent) {
+          await responses_default.error(
+            res,
+            500,
+            "InternalError",
+            "\u8BFB\u53D6\u5BF9\u8C61\u65F6\u53D1\u751F\u9519\u8BEF"
+          );
+        } else {
+          res.end();
+        }
+      });
+    } catch (error) {
+      console.error("Error in GetObject:", error);
+      if (!res.headersSent) {
+        await responses_default.error(res, 500, "InternalError", "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF");
+      }
+    }
+  }
+  /**
+   * 从请求参数中提取存储桶和键
+   * @param {object} req - Express请求对象
+   * @returns {object} 包含存储桶和键的对象
+   */
+  extractBucketAndKey(req) {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    return {
+      bucket: pathParts[0],
+      key: pathParts.slice(1).join("/")
+    };
+  }
+  /**
+   * 根据文件扩展名获取内容类型
+   * @param {string} filename - 文件名
+   * @returns {string} 内容类型
+   */
+  getContentType(filename) {
+    const ext = import_path.default.extname(filename).toLowerCase();
+    const mimeTypes = {
+      ".html": "text/html",
+      ".htm": "text/html",
+      ".css": "text/css",
+      ".js": "application/javascript",
+      ".json": "application/json",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".svg": "image/svg+xml",
+      ".pdf": "application/pdf",
+      ".txt": "text/plain",
+      ".xml": "application/xml",
+      ".zip": "application/zip",
+      ".mp3": "audio/mpeg",
+      ".mp4": "video/mp4",
+      ".webm": "video/webm",
+      ".doc": "application/msword",
+      ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      ".xls": "application/vnd.ms-excel",
+      ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      ".ppt": "application/vnd.ms-powerpoint",
+      ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+    };
+    return mimeTypes[ext] || "application/octet-stream";
+  }
+  /**
+   * 解析Range头
+   * @param {string} rangeHeader - Range头值
+   * @param {number} size - 文件大小
+   * @returns {object|null} 范围对象或null
+   */
+  parseRange(rangeHeader, size) {
+    const matches = rangeHeader.match(/bytes=(\d+)-(\d*)/);
+    if (!matches) return null;
+    const start = parseInt(matches[1], 10);
+    const end = matches[2] ? parseInt(matches[2], 10) : size - 1;
+    if (isNaN(start) || isNaN(end) || start > end || start >= size || end >= size) {
+      return null;
+    }
+    return { start, end };
+  }
+};
+
+// src/handlers/headBucket.ts
+var HeadBucket = class {
+  constructor(server) {
+    this.server = server;
+    this.handle = this.handle.bind(this);
+  }
+  /**
+   * 处理HeadBucket请求
+   * @param {object} req - Express请求对象
+   * @param {object} res - Express响应对象
+   */
+  async handle(req, res) {
+    try {
+      const { bucket } = this.extractBucketAndKey(req);
+      if (!bucket) {
+        res.status(404).end();
+        return;
+      }
+      const bucketExists = await this.server.driver.bucketExists(bucket);
+      if (!bucketExists) {
+        res.status(404).end();
+        return;
+      }
+      const hasAccess = await this.server.driver.hasBucketAccess(bucket);
+      if (!hasAccess) {
+        res.status(403).end();
+        return;
+      }
+      res.set("Date", (/* @__PURE__ */ new Date()).toUTCString());
+      res.set("x-amz-bucket-region", this.server.config.region || "default");
+      res.status(200).end();
+    } catch (error) {
+      console.error("Error in HeadBucket:", error);
+      res.status(500).end();
+    }
+  }
+  /**
+   * 从请求参数中提取存储桶和键
+   * @param {object} req - Express请求对象
+   * @returns {object} 包含存储桶和键的对象
+   */
+  extractBucketAndKey(req) {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    return {
+      bucket: pathParts[0],
+      key: pathParts.slice(1).join("/")
+    };
+  }
+};
+
+// src/handlers/headObject.ts
+var import_crypto3 = __toESM(require("crypto"), 1);
+var import_path2 = __toESM(require("path"), 1);
+var HeadObject = class {
+  constructor(server) {
+    this.server = server;
+    this.handle = this.handle.bind(this);
+  }
+  /**
+   * 处理HeadObject请求
+   * @param {object} req - Express请求对象
+   * @param {object} res - Express响应对象
+   */
+  async handle(req, res) {
+    try {
+      const { bucket, key } = this.extractBucketAndKey(req);
+      if (!bucket) {
+        res.status(404).end();
+        return;
+      }
+      if (!key) {
+        res.status(400).end();
+        return;
+      }
+      const objectPath = `/${bucket}/${key}`;
+      const stats = await this.server.driver.stat(objectPath);
+      if (!stats) {
+        res.status(404).end();
+        return;
+      }
+      if (stats.isDirectory) {
+        res.status(400).end();
+        return;
+      }
+      res.set("Content-Type", this.getContentType(key));
+      res.set("Content-Length", stats.size.toString());
+      res.set("Last-Modified", new Date(stats.mtime).toUTCString());
+      res.set("ETag", `"${stats.uuid || import_crypto3.default.randomUUID()}"`);
+      res.set("Accept-Ranges", "bytes");
+      res.set("Date", (/* @__PURE__ */ new Date()).toUTCString());
+      const metadata = await this.server.driver.getObjectMetadata(objectPath);
+      if (metadata) {
+        Object.entries(metadata).forEach(([key2, value]) => {
+          if (key2.startsWith("x-amz-meta-")) {
+            res.set(key2, value);
+          }
+        });
+      }
+      res.status(200).end();
+    } catch (error) {
+      console.error("Error in HeadObject:", error);
+      res.status(500).end();
+    }
+  }
+  /**
+   * 从请求参数中提取存储桶和键
+   * @param {object} req - Express请求对象
+   * @returns {object} 包含存储桶和键的对象
+   */
+  extractBucketAndKey(req) {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    return {
+      bucket: pathParts[0],
+      key: pathParts.slice(1).join("/")
+    };
+  }
+  /**
+   * 根据文件扩展名获取内容类型
+   * @param {string} filename - 文件名
+   * @returns {string} 内容类型
+   */
+  getContentType(filename) {
+    const ext = import_path2.default.extname(filename).toLowerCase();
+    const mimeTypes = {
+      ".html": "text/html",
+      ".htm": "text/html",
+      ".css": "text/css",
+      ".js": "application/javascript",
+      ".json": "application/json",
+      ".png": "image/png",
+      ".jpg": "image/jpeg",
+      ".jpeg": "image/jpeg",
+      ".gif": "image/gif",
+      ".webp": "image/webp",
+      ".svg": "image/svg+xml",
+      ".pdf": "application/pdf",
+      ".txt": "text/plain",
+      ".xml": "application/xml",
+      ".zip": "application/zip",
+      ".mp3": "audio/mpeg",
+      ".mp4": "video/mp4",
+      ".webm": "video/webm",
+      ".doc": "application/msword",
+      ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+      ".xls": "application/vnd.ms-excel",
+      ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+      ".ppt": "application/vnd.ms-powerpoint",
+      ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+    };
+    return mimeTypes[ext] || "application/octet-stream";
+  }
+};
+
+// src/handlers/listBuckets.ts
+var ListBuckets = class {
+  constructor(server) {
+    this.server = server;
+    this.handle = this.handle.bind(this);
+  }
+  /**
+   * 处理ListBuckets请求
+   * @param {object} req - Express请求对象
+   * @param {object} res - Express响应对象
+   */
+  async handle(req, res) {
+    try {
+      const buckets = await this.server.driver.listBuckets();
+      const owner = {
+        id: this.server.config.accessKeyId || "anonymous",
+        displayName: this.server.config.displayName || "S3 User"
+      };
+      await responses_default.listBuckets(res, buckets, owner);
+    } catch (error) {
+      console.error("Error in ListBuckets:", error);
+      await responses_default.error(res, 500, "InternalError", "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF");
+    }
+  }
+};
+
+// src/handlers/listObjects.ts
+var import_crypto4 = __toESM(require("crypto"), 1);
+var import_path3 = __toESM(require("path"), 1);
+var ListObjects = class {
+  constructor(server) {
+    this.server = server;
+    this.handle = this.handle.bind(this);
+  }
+  /**
+   * 解析请求查询参数
+   * @param {object} req - Express请求对象
+   * @returns {object} 解析后的参数
+   */
+  parseQueryParams(req) {
+    if (!req || !req.query) {
+      return { prefix: "", delimiter: "" };
+    }
+    return {
+      prefix: typeof req.query.prefix === "string" && req.query.prefix.length > 0 ? req.query.prefix : "",
+      delimiter: typeof req.query.delimiter === "string" && req.query.delimiter.length > 0 ? req.query.delimiter : ""
+    };
+  }
+  /**
+   * 规范化前缀
+   * @param {string} prefix - 原始前缀
+   * @returns {string} 规范化后的前缀
+   */
+  normalizePrefix(prefix) {
+    let trimmed = decodeURIComponent(prefix).trim();
+    if (trimmed.length === 0 || trimmed === "/" || trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.includes("../")) {
+      return "/";
+    }
+    if (!trimmed.startsWith("/")) {
+      trimmed = `/${trimmed}`;
+    }
+    return trimmed;
+  }
+  /**
+   * 处理ListObjects请求
+   * @param {object} req - Express请求对象
+   * @param {object} res - Express响应对象
+   */
+  async handle(req, res) {
+    try {
+      if (req.url.includes("?location")) {
+        await responses_default.getBucketLocation(
+          res,
+          this.server.config.region || "default"
+        );
+        return;
+      }
+      const { bucket } = this.extractBucketAndKey(req);
+      if (!bucket) {
+        await responses_default.error(res, 404, "NoSuchBucket", "\u5B58\u50A8\u6876\u4E0D\u5B58\u5728");
+        return;
+      }
+      const params = this.parseQueryParams(req);
+      const normalizedPrefix = this.normalizePrefix(params.prefix);
+      let dirname = this.normalizePrefix(
+        normalizedPrefix === "/" ? `/${bucket}` : import_path3.default.posix.dirname(import_path3.default.posix.join(bucket, normalizedPrefix))
+      );
+      const requestedPath = this.normalizePrefix(
+        import_path3.default.posix.join(bucket, normalizedPrefix)
+      );
+      const requestedPathStats = await this.server.driver.stat(requestedPath);
+      if (requestedPathStats && requestedPathStats.isDirectory) {
+        dirname = requestedPath;
+      }
+      const dirnameStats = await this.server.driver.stat(dirname);
+      if (!dirnameStats) {
+        await responses_default.listObjectsV2(
+          res,
+          params.prefix,
+          [],
+          [],
+          bucket,
+          params.delimiter
+        );
+        return;
+      }
+      const depth = params.delimiter.length === 0 ? 10 : 0;
+      const dirContent = await this.readdir(dirname, depth);
+      const objects = [];
+      const commonPrefixes = [];
+      for (const item of dirContent) {
+        const itemPath = import_path3.default.posix.join(dirname, item);
+        const itemStats = await this.server.driver.stat(itemPath);
+        if (!itemStats) continue;
+        const relativePath = itemPath.startsWith(`/${bucket}/`) ? itemPath.slice(`/${bucket}/`.length) : itemPath;
+        if (itemStats.isDirectory) {
+          commonPrefixes.push(`${relativePath}/`);
+        } else {
+          objects.push({
+            path: relativePath,
+            mtimeMs: itemStats.mtime || Date.now(),
+            size: itemStats.size || 0,
+            uuid: itemStats.uuid || import_crypto4.default.randomUUID()
+          });
+        }
+      }
+      await responses_default.listObjectsV2(
+        res,
+        normalizedPrefix === "/" ? "/" : normalizedPrefix.slice(1),
+        objects,
+        commonPrefixes,
+        bucket,
+        params.delimiter
+      );
+    } catch (error) {
+      console.error("Error in ListObjects:", error);
+      await responses_default.error(res, 500, "InternalError", "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF");
+    }
+  }
+  /**
+   * 从请求参数中提取存储桶和键
+   * @param {object} req - Express请求对象
+   * @returns {object} 包含存储桶和键的对象
+   */
+  extractBucketAndKey(req) {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    return {
+      bucket: pathParts[0],
+      key: pathParts.slice(1).join("/")
+    };
+  }
+  /**
+   * 读取目录内容
+   * @param {string} dirPath - 目录路径
+   * @param {number} depth - 递归深度
+   * @returns {Promise<Array>} 目录内容列表
+   */
+  async readdir(dirPath, depth) {
+    try {
+      if (depth <= 0) {
+        return await this.server.driver.readdir(dirPath);
+      }
+      const items = [];
+      const traverse = async (currentPath, currentDepth) => {
+        if (currentDepth >= depth) {
+          return;
+        }
+        const entries = await this.server.driver.readdir(currentPath);
+        for (const entry of entries) {
+          const entryPath = import_path3.default.posix.join(currentPath, entry);
+          const stats = await this.server.driver.stat(entryPath);
+          items.push(entryPath.slice(dirPath.length));
+          if (stats && stats.isDirectory) {
+            await traverse(entryPath, currentDepth + 1);
+          }
+        }
+      };
+      await traverse(dirPath, 0);
+      return items;
+    } catch (error) {
+      console.error("Error reading directory:", error);
+      return [];
+    }
+  }
+};
+
+// src/handlers/putObject.ts
+var import_crypto5 = __toESM(require("crypto"), 1);
+var PutObject = class {
+  constructor(server) {
+    this.server = server;
+    this.handle = this.handle.bind(this);
+  }
+  /**
+   * 处理PutObject请求
+   * @param {object} req - Express请求对象
+   * @param {object} res - Express响应对象
+   */
+  async handle(req, res) {
+    try {
+      const { bucket, key } = this.extractBucketAndKey(req);
+      if (!bucket) {
+        await responses_default.error(res, 404, "NoSuchBucket", "\u5B58\u50A8\u6876\u4E0D\u5B58\u5728");
+        return;
+      }
+      if (!key) {
+        await responses_default.error(res, 400, "InvalidRequest", "\u65E0\u6548\u7684\u5BF9\u8C61\u952E");
+        return;
+      }
+      const bucketExists = await this.server.driver.bucketExists(bucket);
+      if (!bucketExists) {
+        await responses_default.error(res, 404, "NoSuchBucket", "\u5B58\u50A8\u6876\u4E0D\u5B58\u5728");
+        return;
+      }
+      const objectPath = `/${bucket}/${key}`;
+      const contentLength = parseInt(req.headers["content-length"] || "0", 10);
+      if (isNaN(contentLength) || contentLength < 0) {
+        await responses_default.error(
+          res,
+          400,
+          "InvalidRequest",
+          "\u65E0\u6548\u7684Content-Length"
+        );
+        return;
+      }
+      const writeStream = await this.server.driver.createWriteStream(objectPath);
+      const md5Hash = import_crypto5.default.createHash("md5");
+      let bytesWritten = 0;
+      await new Promise((resolve, reject) => {
+        let settled = false;
+        const rejectOnce = (error) => {
+          if (settled) return;
+          settled = true;
+          writeStream.destroy();
+          reject(error);
+        };
+        const complete = async () => {
+          if (settled) return;
+          settled = true;
+          try {
+            const etag = md5Hash.digest("hex");
+            await this.server.driver.updateObjectMetadata(objectPath, {
+              etag,
+              contentType: req.headers["content-type"] || "application/octet-stream",
+              contentLength: bytesWritten,
+              lastModified: /* @__PURE__ */ new Date()
+            });
+            res.set("ETag", `"${etag}"`);
+            res.set("Date", (/* @__PURE__ */ new Date()).toUTCString());
+            res.status(200).end();
+            resolve();
+          } catch (error) {
+            reject(error);
+          }
+        };
+        writeStream.on("error", rejectOnce);
+        const rawBody = req.body;
+        if (Buffer.isBuffer(rawBody) || rawBody instanceof Uint8Array) {
+          const chunk = Buffer.from(rawBody);
+          if (chunk.length > 0) {
+            writeStream.write(chunk);
+            md5Hash.update(chunk);
+            bytesWritten += chunk.length;
+          }
+          writeStream.end(() => void complete());
+          return;
+        }
+        if (typeof rawBody === "string") {
+          const chunk = Buffer.from(rawBody);
+          if (chunk.length > 0) {
+            writeStream.write(chunk);
+            md5Hash.update(chunk);
+            bytesWritten += chunk.length;
+          }
+          writeStream.end(() => void complete());
+          return;
+        }
+        req.on("data", (chunk) => {
+          writeStream.write(chunk);
+          md5Hash.update(chunk);
+          bytesWritten += chunk.length;
+        });
+        req.on("end", () => {
+          writeStream.end(() => void complete());
+        });
+        req.on("error", rejectOnce);
+      });
+    } catch (error) {
+      console.error("Error in PutObject:", error);
+      if (!res.headersSent) {
+        await responses_default.error(res, 500, "InternalError", "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF");
+      }
+    }
+  }
+  /**
+   * 从请求参数中提取存储桶和键
+   * @param {object} req - Express请求对象
+   * @returns {object} 包含存储桶和键的对象
+   */
+  extractBucketAndKey(req) {
+    const url = new URL(req.url, `http://${req.headers.host}`);
+    const pathParts = url.pathname.split("/").filter(Boolean);
+    return {
+      bucket: pathParts[0],
+      key: pathParts.slice(1).join("/")
+    };
+  }
+};
+
+// src/index.ts
+var S3Server = class {
+  /**
+   * 创建S3服务器实例
+   * @param {Object} config - 服务器配置
+   * @param {Object} driver - 存储驱动
+   */
+  constructor(config, driver) {
+    this.config = {
+      hostname: config.hostname || "0.0.0.0",
+      port: config.port || 9e3,
+      https: config.https || false,
+      region: config.region || "default",
+      accessKeyId: config.accessKeyId || "accessKey1",
+      secretAccessKey: config.secretAccessKey || "verySecretKey1",
+      displayName: config.displayName || "S3 User"
+    };
+    this.driver = driver;
+    this.app = (0, import_express.default)();
+    this.server = null;
+    this.handlers = {
+      listBuckets: new ListBuckets(this),
+      listObjects: new ListObjects(this),
+      getObject: new GetObject(this),
+      putObject: new PutObject(this),
+      deleteObject: new DeleteObject(this),
+      deleteObjects: new DeleteObjects(this),
+      headObject: new HeadObject(this),
+      headBucket: new HeadBucket(this),
+      createBucket: new CreateBucket(this),
+      deleteBucket: new DeleteBucket(this)
+    };
+    this.setupMiddleware();
+    this.setupRoutes();
+  }
+  /**
+   * 配置Express中间件
+   */
+  setupMiddleware() {
+    this.app.use(
+      import_body_parser.default.raw({
+        type: "*/*",
+        limit: "10gb"
+      })
+    );
+    this.app.use((req, res, next) => {
+      const ctx = context_default(req);
+      req.s3Context = ctx;
+      if (this.config.accessKeyId && this.config.secretAccessKey) {
+        const { accessKeyId, secretAccessKey } = ctx.auth;
+        if (accessKeyId !== this.config.accessKeyId || secretAccessKey !== this.config.secretAccessKey) {
+          res.status(403).send({
+            Error: {
+              Code: "AccessDenied",
+              Message: "\u8BBF\u95EE\u88AB\u62D2\u7EDD"
+            }
+          });
+          return;
+        }
+      }
+      next();
+    });
+    this.app.use((req, res, next) => {
+      console.log(`${(/* @__PURE__ */ new Date()).toISOString()} - ${req.method} ${req.url}`);
+      next();
+    });
+  }
+  /**
+   * 配置API路由
+   */
+  setupRoutes() {
+    this.app.get("/", (req, res) => {
+      this.handlers.listBuckets.handle(req, res);
+    });
+    this.app.head("/:bucket", (req, res) => {
+      this.handlers.headBucket.handle(req, res);
+    });
+    this.app.get("/:bucket", (req, res) => {
+      this.handlers.listObjects.handle(req, res);
+    });
+    this.app.put("/:bucket", (req, res) => {
+      this.handlers.createBucket.handle(req, res);
+    });
+    this.app.delete("/:bucket", (req, res) => {
+      this.handlers.deleteBucket.handle(req, res);
+    });
+    this.app.head("/:bucket/*", (req, res) => {
+      this.handlers.headObject.handle(req, res);
+    });
+    this.app.get("/:bucket/*", (req, res) => {
+      this.handlers.getObject.handle(req, res);
+    });
+    this.app.put("/:bucket/*", (req, res) => {
+      this.handlers.putObject.handle(req, res);
+    });
+    this.app.delete("/:bucket/*", (req, res) => {
+      this.handlers.deleteObject.handle(req, res);
+    });
+    this.app.post("/:bucket", (req, res) => {
+      if (req.query.delete !== void 0) {
+        this.handlers.deleteObjects.handle(req, res);
+      } else {
+        res.status(400).send({
+          Error: {
+            Code: "InvalidRequest",
+            Message: "\u65E0\u6548\u7684\u8BF7\u6C42"
+          }
+        });
+      }
+    });
+    this.app.use((req, res) => {
+      res.status(404).send({
+        Error: {
+          Code: "NotFound",
+          Message: "\u8BF7\u6C42\u7684\u8D44\u6E90\u4E0D\u5B58\u5728"
+        }
+      });
+    });
+    this.app.use((err, req, res, next) => {
+      console.error("Server error:", err);
+      res.status(500).send({
+        Error: {
+          Code: "InternalError",
+          Message: "\u670D\u52A1\u5668\u5185\u90E8\u9519\u8BEF"
+        }
+      });
+    });
+  }
+  /**
+   * 启动服务器
+   * @returns {Promise<void>}
+   */
+  async start() {
+    return new Promise((resolve, reject) => {
+      try {
+        if (this.config.https) {
+          const options = {
+            key: "...",
+            // 私钥
+            cert: "..."
+            // 证书
+          };
+          this.server = import_https.default.createServer(options, this.app);
+        } else {
+          this.server = import_http.default.createServer(this.app);
+        }
+        this.server.listen(this.config.port, this.config.hostname, () => {
+          console.log(
+            `S3\u670D\u52A1\u5668\u5DF2\u542F\u52A8: ${this.config.https ? "https" : "http"}://${this.config.hostname}:${this.config.port}`
+          );
+          resolve();
+        });
+        this.server.on("error", (err) => {
+          console.error("\u670D\u52A1\u5668\u542F\u52A8\u5931\u8D25:", err);
+          reject(err);
+        });
+      } catch (error) {
+        console.error("\u542F\u52A8\u670D\u52A1\u5668\u65F6\u53D1\u751F\u9519\u8BEF:", error);
+        reject(error);
+      }
+    });
+  }
+  /**
+   * 停止服务器
+   * @returns {Promise<void>}
+   */
+  async stop() {
+    return new Promise((resolve, reject) => {
+      if (!this.server) {
+        resolve();
+        return;
+      }
+      this.server.close((err) => {
+        if (err) {
+          console.error("\u505C\u6B62\u670D\u52A1\u5668\u65F6\u53D1\u751F\u9519\u8BEF:", err);
+          reject(err);
+          return;
+        }
+        console.log("S3\u670D\u52A1\u5668\u5DF2\u505C\u6B62");
+        this.server = null;
+        resolve();
+      });
+    });
+  }
+};
+module.exports = module.exports.default; module.exports.default = module.exports;