@h-ai/storage 0.1.0-alpha5

package/dist/node.js

@@ -0,0 +1,959 @@
+import { HaiStorageError, StorageConfigSchema } from './chunk-KHZOR6CR.js';
+export { HaiStorageError, LocalConfigSchema, PresignOptionsSchema, PresignUploadOptionsSchema, S3ConfigSchema, StorageConfigSchema, StorageTypeSchema } from './chunk-KHZOR6CR.js';
+import { storageM, MIME_TYPES, MIME_TYPE_DEFAULT } from './chunk-U427BQIQ.js';
+export { downloadAndSave, downloadWithPresignedUrl, formatFileSize, getFileExtension, getMimeType, uploadWithPresignedUrl } from './chunk-U427BQIQ.js';
+import { core, err, ok } from '@h-ai/core';
+import { Buffer } from 'buffer';
+import * as crypto from 'crypto';
+import * as fs from 'fs';
+import * as fsp from 'fs/promises';
+import * as path from 'path';
+import { S3Client, ListObjectsV2Command, PutObjectCommand, GetObjectCommand, CopyObjectCommand, DeleteObjectsCommand, DeleteObjectCommand, HeadObjectCommand } from '@aws-sdk/client-s3';
+import { getSignedUrl } from '@aws-sdk/s3-request-presigner';
+
+var logger = core.logger.child({ module: "storage", scope: "provider-local" });
+function toStorageError(error, key) {
+  const e = error;
+  if (e.code === "ENOENT") {
+    return {
+      ...HaiStorageError.NOT_FOUND,
+      message: storageM("storage_fileNotFound", { params: { key: key ?? "" } }),
+      cause: error
+    };
+  }
+  if (e.code === "EACCES" || e.code === "EPERM") {
+    return {
+      ...HaiStorageError.PERMISSION_DENIED,
+      message: storageM("storage_permissionDenied", { params: { key: key ?? "" } }),
+      cause: error
+    };
+  }
+  if (e.code === "ENOSPC") {
+    return {
+      ...HaiStorageError.QUOTA_EXCEEDED,
+      message: storageM("storage_diskSpaceInsufficient"),
+      cause: error
+    };
+  }
+  if (e.code === "EISDIR") {
+    return {
+      ...HaiStorageError.INVALID_PATH,
+      message: storageM("storage_pathIsDir", { params: { key: key ?? "" } }),
+      cause: error
+    };
+  }
+  if (e.code === "EINVAL") {
+    return {
+      ...HaiStorageError.INVALID_PATH,
+      message: e.message || storageM("storage_pathTraversal"),
+      cause: error
+    };
+  }
+  return {
+    code: HaiStorageError.IO_ERROR.code,
+    message: storageM("storage_ioError", { params: { error: e.message ?? "" } }),
+    cause: error
+  };
+}
+function getMimeType2(filePath) {
+  const ext = path.extname(filePath).toLowerCase().replace(".", "");
+  return MIME_TYPES[ext] || MIME_TYPE_DEFAULT;
+}
+function calculateEtag(stat2) {
+  return `"${stat2.size.toString(16)}-${stat2.mtimeMs.toString(16)}"`;
+}
+function isMetaFile(key) {
+  return key.endsWith(".meta.json");
+}
+function createInvalidPathError() {
+  const error = new Error(storageM("storage_pathTraversal"));
+  error.code = "EINVAL";
+  return error;
+}
+function hasPathTraversalSegment(key) {
+  const segments = key.split(/[\\/]+/).filter(Boolean);
+  return segments.includes("..");
+}
+function safePath(root, key) {
+  if (path.isAbsolute(key)) {
+    throw createInvalidPathError();
+  }
+  if (key.includes("\0") || hasPathTraversalSegment(key)) {
+    throw createInvalidPathError();
+  }
+  const normalized = path.normalize(key);
+  const fullPath = path.resolve(root, normalized);
+  const realRoot = path.resolve(root);
+  const inRoot = fullPath === realRoot || fullPath.startsWith(`${realRoot}${path.sep}`);
+  if (!inRoot) {
+    throw createInvalidPathError();
+  }
+  return fullPath;
+}
+function createLocalProvider() {
+  let config = null;
+  let connected = false;
+  function getConfig() {
+    if (!config) {
+      throw new Error(storageM("storage_localNotInitialized"));
+    }
+    return config;
+  }
+  function fullPath(key) {
+    return safePath(getConfig().root, key);
+  }
+  function toBuffer(data) {
+    if (typeof data === "string") {
+      return Buffer.from(data);
+    }
+    if (data instanceof Buffer) {
+      return data;
+    }
+    return Buffer.from(data);
+  }
+  const file = {
+    async put(key, data, options = {}) {
+      if (isMetaFile(key)) {
+        return err(
+          HaiStorageError.INVALID_PATH,
+          storageM("storage_metaFileAccess", { params: { key } })
+        );
+      }
+      try {
+        const filePath = fullPath(key);
+        const buffer = toBuffer(data);
+        logger.debug("Putting file", { key, size: buffer.length });
+        const dir2 = path.dirname(filePath);
+        await fsp.mkdir(dir2, { recursive: true, mode: getConfig().directoryMode });
+        await fsp.writeFile(filePath, buffer, { mode: getConfig().fileMode });
+        const stat2 = await fsp.stat(filePath);
+        const metadata = {
+          key,
+          size: stat2.size,
+          contentType: options.contentType || getMimeType2(key),
+          lastModified: stat2.mtime,
+          etag: calculateEtag(stat2),
+          metadata: options.metadata
+        };
+        if (options.metadata) {
+          const metaPath = `${filePath}.meta.json`;
+          await fsp.writeFile(metaPath, JSON.stringify({
+            contentType: options.contentType,
+            metadata: options.metadata
+          }));
+        }
+        return ok(metadata);
+      } catch (error) {
+        logger.warn("Put file failed", { key, error });
+        return err(toStorageError(error, key));
+      }
+    },
+    async get(key, options = {}) {
+      if (isMetaFile(key)) {
+        return err(
+          HaiStorageError.INVALID_PATH,
+          storageM("storage_metaFileAccess", { params: { key } })
+        );
+      }
+      try {
+        const filePath = fullPath(key);
+        if (options.rangeStart !== void 0 || options.rangeEnd !== void 0) {
+          const stat2 = await fsp.stat(filePath);
+          const start = options.rangeStart ?? 0;
+          const end = options.rangeEnd !== void 0 ? options.rangeEnd : stat2.size - 1;
+          return new Promise((resolve2) => {
+            const chunks = [];
+            const stream = fs.createReadStream(filePath, { start, end });
+            stream.on("data", (chunk) => chunks.push(chunk));
+            stream.on("end", () => resolve2(ok(Buffer.concat(chunks))));
+            stream.on("error", (error) => resolve2(err(toStorageError(error, key))));
+          });
+        }
+        const data = await fsp.readFile(filePath);
+        return ok(data);
+      } catch (error) {
+        return err(toStorageError(error, key));
+      }
+    },
+    async head(key) {
+      if (isMetaFile(key)) {
+        return err(
+          HaiStorageError.INVALID_PATH,
+          storageM("storage_metaFileAccess", { params: { key } })
+        );
+      }
+      try {
+        const filePath = fullPath(key);
+        const stat2 = await fsp.stat(filePath);
+        if (stat2.isDirectory()) {
+          return err(
+            HaiStorageError.INVALID_PATH,
+            storageM("storage_pathIsDir", { params: { key } })
+          );
+        }
+        let customMetadata = {};
+        try {
+          const metaPath = `${filePath}.meta.json`;
+          const metaContent = await fsp.readFile(metaPath, "utf-8");
+          customMetadata = JSON.parse(metaContent);
+        } catch {
+        }
+        const etag = `"${stat2.size.toString(16)}-${stat2.mtimeMs.toString(16)}"`;
+        return ok({
+          key,
+          size: stat2.size,
+          contentType: customMetadata.contentType || getMimeType2(key),
+          lastModified: stat2.mtime,
+          etag,
+          metadata: customMetadata.metadata
+        });
+      } catch (error) {
+        return err(toStorageError(error, key));
+      }
+    },
+    async exists(key) {
+      if (isMetaFile(key)) {
+        return err(
+          HaiStorageError.INVALID_PATH,
+          storageM("storage_metaFileAccess", { params: { key } })
+        );
+      }
+      try {
+        const filePath = fullPath(key);
+        await fsp.access(filePath, fs.constants.F_OK);
+        return ok(true);
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          return ok(false);
+        }
+        return err(toStorageError(error, key));
+      }
+    },
+    async delete(key) {
+      if (isMetaFile(key)) {
+        return err(
+          HaiStorageError.INVALID_PATH,
+          storageM("storage_metaFileAccess", { params: { key } })
+        );
+      }
+      try {
+        const filePath = fullPath(key);
+        logger.debug("Deleting file", { key });
+        await fsp.unlink(filePath);
+        try {
+          await fsp.unlink(`${filePath}.meta.json`);
+        } catch {
+        }
+        return ok(void 0);
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          return ok(void 0);
+        }
+        logger.warn("Delete file failed", { key, error });
+        return err(toStorageError(error, key));
+      }
+    },
+    async deleteMany(keys) {
+      const results = await Promise.allSettled(keys.map((key) => file.delete(key)));
+      const errors = [];
+      for (const result of results) {
+        if (result.status === "fulfilled" && !result.value.success) {
+          errors.push(result.value.error);
+        }
+      }
+      if (errors.length > 0) {
+        return err(
+          HaiStorageError.OPERATION_FAILED,
+          storageM("storage_deleteManyFailed", { params: { count: errors.length } }),
+          errors
+        );
+      }
+      return ok(void 0);
+    },
+    async copy(sourceKey, destKey, options = {}) {
+      if (isMetaFile(sourceKey) || isMetaFile(destKey)) {
+        return err(
+          HaiStorageError.INVALID_PATH,
+          storageM("storage_metaFileAccess", { params: { key: sourceKey } }),
+          sourceKey
+        );
+      }
+      try {
+        const sourcePath = fullPath(sourceKey);
+        const destPath = fullPath(destKey);
+        logger.debug("Copying file", { sourceKey, destKey });
+        await fsp.mkdir(path.dirname(destPath), { recursive: true, mode: getConfig().directoryMode });
+        await fsp.copyFile(sourcePath, destPath);
+        const stat2 = await fsp.stat(destPath);
+        const metadata = {
+          key: destKey,
+          size: stat2.size,
+          contentType: options.contentType || getMimeType2(destKey),
+          lastModified: stat2.mtime,
+          etag: calculateEtag(stat2),
+          metadata: options.metadata
+        };
+        if (options.contentType || options.metadata) {
+          const metaPath = `${destPath}.meta.json`;
+          await fsp.writeFile(metaPath, JSON.stringify({
+            contentType: options.contentType,
+            metadata: options.metadata
+          }));
+        }
+        return ok(metadata);
+      } catch (error) {
+        return err(toStorageError(error, sourceKey));
+      }
+    }
+  };
+  const dir = {
+    async list(options = {}) {
+      try {
+        const cfg = getConfig();
+        const prefix = options.prefix || "";
+        const delimiter = options.delimiter || "";
+        const maxKeys = options.maxKeys || 1e3;
+        const basePath = safePath(cfg.root, prefix);
+        const files = [];
+        const commonPrefixes = /* @__PURE__ */ new Set();
+        async function readDir(dirPath) {
+          let entries;
+          try {
+            entries = await fsp.readdir(dirPath, { withFileTypes: true });
+          } catch {
+            return;
+          }
+          for (const entry of entries) {
+            if (files.length >= maxKeys)
+              return;
+            const fullEntryPath = path.join(dirPath, entry.name);
+            const key = path.relative(cfg.root, fullEntryPath).replace(/\\/g, "/");
+            if (entry.name.endsWith(".meta.json"))
+              continue;
+            if (entry.isDirectory()) {
+              if (delimiter) {
+                commonPrefixes.add(`${key}/`);
+              } else {
+                await readDir(fullEntryPath);
+              }
+            } else if (entry.isFile()) {
+              const stat2 = await fsp.stat(fullEntryPath);
+              files.push({
+                key,
+                size: stat2.size,
+                contentType: getMimeType2(key),
+                lastModified: stat2.mtime
+              });
+            }
+          }
+        }
+        await readDir(basePath);
+        return ok({
+          files,
+          commonPrefixes: Array.from(commonPrefixes),
+          isTruncated: files.length >= maxKeys
+        });
+      } catch (error) {
+        return err(toStorageError(error));
+      }
+    },
+    async delete(prefix) {
+      try {
+        const dirPath = fullPath(prefix);
+        await fsp.rm(dirPath, { recursive: true, force: true });
+        return ok(void 0);
+      } catch (error) {
+        if (error.code === "ENOENT") {
+          return ok(void 0);
+        }
+        return err(toStorageError(error, prefix));
+      }
+    }
+  };
+  const presign = {
+    async getUrl(key, options) {
+      const expiresIn = options?.expiresIn || 3600;
+      const expires = Math.floor(Date.now() / 1e3) + expiresIn;
+      const signature = crypto.createHash("sha256").update(`${key}:${expires}`).digest("hex").slice(0, 16);
+      return ok(`local://${key}?expires=${expires}&signature=${signature}`);
+    },
+    async putUrl(key, options) {
+      const expiresIn = options?.expiresIn || 3600;
+      const expires = Math.floor(Date.now() / 1e3) + expiresIn;
+      const signature = crypto.createHash("sha256").update(`put:${key}:${expires}`).digest("hex").slice(0, 16);
+      return ok(`local://${key}?action=put&expires=${expires}&signature=${signature}`);
+    },
+    publicUrl(_key) {
+      return null;
+    }
+  };
+  return {
+    name: "local",
+    file,
+    dir,
+    presign,
+    async connect(cfg) {
+      if (cfg.type !== "local") {
+        return err(
+          HaiStorageError.CONFIG_ERROR,
+          storageM("storage_localConfigTypeError")
+        );
+      }
+      try {
+        config = cfg;
+        logger.info("Connecting local provider", { root: cfg.root });
+        await fsp.mkdir(cfg.root, { recursive: true, mode: cfg.directoryMode });
+        connected = true;
+        logger.info("Local provider connected", { root: cfg.root });
+        return ok(void 0);
+      } catch (error) {
+        logger.error("Local provider connect failed", { error });
+        config = null;
+        return err(toStorageError(error));
+      }
+    },
+    async close() {
+      logger.info("Local provider disconnected");
+      config = null;
+      connected = false;
+    },
+    isConnected() {
+      return connected;
+    }
+  };
+}
+var logger2 = core.logger.child({ module: "storage", scope: "provider-s3" });
+function sanitizeEndpointUrl(url) {
+  try {
+    const parsed = new URL(url);
+    if (parsed.username)
+      parsed.username = "***";
+    if (parsed.password)
+      parsed.password = "***";
+    return parsed.toString();
+  } catch {
+    return "(invalid url)";
+  }
+}
+function toStorageError2(error, key) {
+  const e = error;
+  if (e.name === "NoSuchKey" || e.Code === "NoSuchKey" || e.name === "NotFound" || e.Code === "NotFound" || e.name === "404" || e.$metadata?.httpStatusCode === 404) {
+    return {
+      ...HaiStorageError.NOT_FOUND,
+      message: storageM("storage_fileNotFound", { params: { key: key ?? "" } }),
+      cause: error
+    };
+  }
+  if (e.name === "AccessDenied" || e.Code === "AccessDenied") {
+    return {
+      ...HaiStorageError.PERMISSION_DENIED,
+      message: storageM("storage_permissionDenied", { params: { key: key ?? "" } }),
+      cause: error
+    };
+  }
+  if (e.name === "NoSuchBucket" || e.Code === "NoSuchBucket") {
+    return {
+      ...HaiStorageError.CONFIG_ERROR,
+      message: storageM("storage_bucketNotExist"),
+      cause: error
+    };
+  }
+  if (e.name === "NetworkError" || e.name?.includes("ECONNREFUSED")) {
+    return {
+      ...HaiStorageError.NETWORK_ERROR,
+      message: storageM("storage_networkError"),
+      cause: error
+    };
+  }
+  return {
+    ...HaiStorageError.OPERATION_FAILED,
+    message: storageM("storage_operationFailed", { params: { error: e.message ?? "" } }),
+    cause: error
+  };
+}
+function withPrefix(key, prefix) {
+  if (!prefix)
+    return key;
+  return `${prefix.replace(/\/+$/, "")}/${key.replace(/^\/+/, "")}`;
+}
+function withoutPrefix(key, prefix) {
+  if (!prefix)
+    return key;
+  const normalizedPrefix = `${prefix.replace(/\/+$/, "")}/`;
+  if (key.startsWith(normalizedPrefix)) {
+    return key.slice(normalizedPrefix.length);
+  }
+  return key;
+}
+function createS3Provider() {
+  let client = null;
+  let config = null;
+  function getClient() {
+    if (!client) {
+      throw new Error(storageM("storage_s3ClientNotInitialized"));
+    }
+    return client;
+  }
+  function getConfig() {
+    if (!config) {
+      throw new Error(storageM("storage_s3ConfigNotInitialized"));
+    }
+    return config;
+  }
+  function fullKey(key) {
+    return withPrefix(key, getConfig().prefix);
+  }
+  const file = {
+    async put(key, data, options = {}) {
+      try {
+        const s3Client = getClient();
+        const s3Config = getConfig();
+        const fullPath = fullKey(key);
+        const body = typeof data === "string" ? Buffer.from(data) : data;
+        await s3Client.send(new PutObjectCommand({
+          Bucket: s3Config.bucket,
+          Key: fullPath,
+          Body: body,
+          ContentType: options.contentType,
+          Metadata: options.metadata,
+          CacheControl: options.cacheControl,
+          ContentDisposition: options.contentDisposition
+        }));
+        const headResult = await file.head(key);
+        if (headResult.success) {
+          return headResult;
+        }
+        return ok({
+          key,
+          size: body.length,
+          contentType: options.contentType || "application/octet-stream",
+          lastModified: /* @__PURE__ */ new Date()
+        });
+      } catch (error) {
+        return err(toStorageError2(error, key));
+      }
+    },
+    async get(key, options = {}) {
+      try {
+        const s3Client = getClient();
+        const s3Config = getConfig();
+        const fullPath = fullKey(key);
+        let Range;
+        if (options.rangeStart !== void 0 || options.rangeEnd !== void 0) {
+          const start = options.rangeStart ?? 0;
+          const end = options.rangeEnd !== void 0 ? options.rangeEnd : "";
+          Range = `bytes=${start}-${end}`;
+        }
+        const response = await s3Client.send(new GetObjectCommand({
+          Bucket: s3Config.bucket,
+          Key: fullPath,
+          Range
+        }));
+        if (!response.Body) {
+          return err(
+            HaiStorageError.OPERATION_FAILED,
+            storageM("storage_responseBodyEmpty")
+          );
+        }
+        const chunks = [];
+        const stream = response.Body;
+        for await (const chunk of stream) {
+          chunks.push(chunk);
+        }
+        return ok(Buffer.concat(chunks));
+      } catch (error) {
+        return err(toStorageError2(error, key));
+      }
+    },
+    async head(key) {
+      try {
+        const s3Client = getClient();
+        const s3Config = getConfig();
+        const fullPath = fullKey(key);
+        const response = await s3Client.send(new HeadObjectCommand({
+          Bucket: s3Config.bucket,
+          Key: fullPath
+        }));
+        return ok({
+          key,
+          size: response.ContentLength || 0,
+          contentType: response.ContentType || "application/octet-stream",
+          lastModified: response.LastModified || /* @__PURE__ */ new Date(),
+          etag: response.ETag,
+          metadata: response.Metadata
+        });
+      } catch (error) {
+        return err(toStorageError2(error, key));
+      }
+    },
+    async exists(key) {
+      const result = await file.head(key);
+      if (result.success) {
+        return ok(true);
+      }
+      if (result.error.code === HaiStorageError.NOT_FOUND.code) {
+        return ok(false);
+      }
+      return err(result.error);
+    },
+    async delete(key) {
+      try {
+        const s3Client = getClient();
+        const s3Config = getConfig();
+        const fullPath = fullKey(key);
+        await s3Client.send(new DeleteObjectCommand({
+          Bucket: s3Config.bucket,
+          Key: fullPath
+        }));
+        return ok(void 0);
+      } catch (error) {
+        return err(toStorageError2(error, key));
+      }
+    },
+    async deleteMany(keys) {
+      try {
+        const s3Client = getClient();
+        const s3Config = getConfig();
+        if (keys.length === 0) {
+          return ok(void 0);
+        }
+        await s3Client.send(new DeleteObjectsCommand({
+          Bucket: s3Config.bucket,
+          Delete: {
+            Objects: keys.map((key) => ({ Key: fullKey(key) }))
+          }
+        }));
+        return ok(void 0);
+      } catch (error) {
+        return err(toStorageError2(error));
+      }
+    },
+    async copy(sourceKey, destKey, options = {}) {
+      try {
+        const s3Client = getClient();
+        const s3Config = getConfig();
+        const sourceFullPath = fullKey(sourceKey);
+        const destFullPath = fullKey(destKey);
+        await s3Client.send(new CopyObjectCommand({
+          Bucket: s3Config.bucket,
+          CopySource: `${s3Config.bucket}/${sourceFullPath}`,
+          Key: destFullPath,
+          ContentType: options.contentType,
+          Metadata: options.metadata,
+          MetadataDirective: options.metadata || options.contentType ? "REPLACE" : "COPY"
+        }));
+        return file.head(destKey);
+      } catch (error) {
+        return err(toStorageError2(error, sourceKey));
+      }
+    }
+  };
+  const dir = {
+    async list(options = {}) {
+      try {
+        const s3Client = getClient();
+        const s3Config = getConfig();
+        let prefix = s3Config.prefix || "";
+        if (options.prefix) {
+          prefix = withPrefix(options.prefix, s3Config.prefix);
+        }
+        const response = await s3Client.send(new ListObjectsV2Command({
+          Bucket: s3Config.bucket,
+          Prefix: prefix || void 0,
+          Delimiter: options.delimiter,
+          MaxKeys: options.maxKeys,
+          ContinuationToken: options.continuationToken
+        }));
+        const files = (response.Contents || []).map((item) => ({
+          key: withoutPrefix(item.Key || "", s3Config.prefix),
+          size: item.Size || 0,
+          contentType: "application/octet-stream",
+          // ListObjects 不返回 ContentType
+          lastModified: item.LastModified || /* @__PURE__ */ new Date(),
+          etag: item.ETag
+        }));
+        const commonPrefixes = (response.CommonPrefixes || []).map((p) => withoutPrefix(p.Prefix || "", s3Config.prefix)).filter((p) => p.length > 0);
+        return ok({
+          files,
+          commonPrefixes,
+          nextContinuationToken: response.NextContinuationToken,
+          isTruncated: response.IsTruncated || false
+        });
+      } catch (error) {
+        return err(toStorageError2(error));
+      }
+    },
+    async delete(prefix) {
+      try {
+        let continuationToken;
+        do {
+          const listResult = await dir.list({
+            prefix,
+            continuationToken,
+            maxKeys: 1e3
+          });
+          if (!listResult.success) {
+            return err(listResult.error);
+          }
+          const keys = listResult.data.files.map((f) => f.key);
+          if (keys.length > 0) {
+            const deleteResult = await file.deleteMany(keys);
+            if (!deleteResult.success) {
+              return deleteResult;
+            }
+          }
+          continuationToken = listResult.data.nextContinuationToken;
+        } while (continuationToken);
+        return ok(void 0);
+      } catch (error) {
+        return err(toStorageError2(error));
+      }
+    }
+  };
+  const presign = {
+    async getUrl(key, options) {
+      try {
+        const s3Client = getClient();
+        const s3Config = getConfig();
+        const fullPath = fullKey(key);
+        const command = new GetObjectCommand({
+          Bucket: s3Config.bucket,
+          Key: fullPath,
+          ResponseContentType: options?.responseContentType,
+          ResponseContentDisposition: options?.responseContentDisposition
+        });
+        const url = await getSignedUrl(s3Client, command, {
+          expiresIn: options?.expiresIn || 3600
+        });
+        return ok(url);
+      } catch (error) {
+        return err(
+          HaiStorageError.PRESIGN_FAILED,
+          storageM("storage_presignUrlFailed"),
+          error
+        );
+      }
+    },
+    async putUrl(key, options) {
+      try {
+        const s3Client = getClient();
+        const s3Config = getConfig();
+        const fullPath = fullKey(key);
+        const command = new PutObjectCommand({
+          Bucket: s3Config.bucket,
+          Key: fullPath,
+          ContentType: options?.contentType || "application/octet-stream"
+        });
+        const url = await getSignedUrl(s3Client, command, {
+          expiresIn: options?.expiresIn || 3600
+        });
+        return ok(url);
+      } catch (error) {
+        return err(
+          HaiStorageError.PRESIGN_FAILED,
+          storageM("storage_presignUploadUrlFailed"),
+          error
+        );
+      }
+    },
+    publicUrl(key) {
+      const s3Config = getConfig();
+      if (!s3Config.publicUrl) {
+        return null;
+      }
+      const fullPath = fullKey(key);
+      return `${s3Config.publicUrl.replace(/\/+$/, "")}/${fullPath}`;
+    }
+  };
+  return {
+    name: "s3",
+    file,
+    dir,
+    presign,
+    async connect(cfg) {
+      if (cfg.type !== "s3") {
+        return err(
+          HaiStorageError.CONFIG_ERROR,
+          storageM("storage_s3ConfigTypeError")
+        );
+      }
+      try {
+        config = cfg;
+        logger2.info("Connecting S3 provider", {
+          bucket: cfg.bucket,
+          region: cfg.region,
+          endpoint: cfg.endpoint ? sanitizeEndpointUrl(cfg.endpoint) : void 0
+        });
+        client = new S3Client({
+          region: cfg.region,
+          endpoint: cfg.endpoint,
+          forcePathStyle: cfg.forcePathStyle,
+          credentials: {
+            accessKeyId: cfg.accessKeyId,
+            secretAccessKey: cfg.secretAccessKey
+          }
+        });
+        await client.send(new ListObjectsV2Command({
+          Bucket: cfg.bucket,
+          MaxKeys: 1
+        }));
+        logger2.info("S3 provider connected", { bucket: cfg.bucket });
+        return ok(void 0);
+      } catch (error) {
+        logger2.error("S3 provider connect failed", { error });
+        config = null;
+        client = null;
+        return err(toStorageError2(error));
+      }
+    },
+    async close() {
+      if (client) {
+        client.destroy();
+        client = null;
+        config = null;
+        logger2.info("S3 provider disconnected");
+      }
+    },
+    isConnected() {
+      return client !== null && config !== null;
+    }
+  };
+}
+
+// src/storage-main.ts
+var logger3 = core.logger.child({ module: "storage", scope: "main" });
+var currentProvider = null;
+var currentConfig = null;
+var initInProgress = false;
+function createProvider(config) {
+  switch (config.type) {
+    case "s3":
+      return createS3Provider();
+    case "local":
+      return createLocalProvider();
+    default:
+      throw new Error(storageM("storage_unsupportedType", { params: { type: config.type } }));
+  }
+}
+var notInitialized = core.module.createNotInitializedKit(
+  HaiStorageError.NOT_INITIALIZED,
+  () => storageM("storage_notInitialized")
+);
+var notInitializedFile = notInitialized.proxy();
+var notInitializedDir = notInitialized.proxy();
+var notInitializedPresignBase = notInitialized.proxy();
+var notInitializedPresign = new Proxy(
+  notInitializedPresignBase,
+  {
+    get: (target, prop, receiver) => prop === "publicUrl" ? () => null : Reflect.get(target, prop, receiver)
+  }
+);
+var storage = {
+  /**
+   * 初始化存储连接。
+   *
+   * 如果当前已有活跃连接，会先自动 close 再重新初始化。
+   * 配置会通过 Zod Schema 校验；校验失败或连接异常会返回 `CONNECTION_FAILED`。
+   *
+   * @param config 存储配置（S3 或本地），支持省略带默认值的字段。
+   * @returns 成功时返回 ok(undefined)；失败时返回包含错误码和消息的 err。
+   */
+  async init(config) {
+    if (initInProgress) {
+      logger3.warn("Storage init already in progress, skipping concurrent call");
+      return err(
+        HaiStorageError.OPERATION_FAILED,
+        storageM("storage_operationFailed", { params: { error: "Concurrent initialization detected" } })
+      );
+    }
+    initInProgress = true;
+    try {
+      if (currentProvider) {
+        logger3.warn("Storage module is already initialized, reinitializing");
+        await storage.close();
+      }
+      logger3.info("Initializing storage module");
+      const parseResult = StorageConfigSchema.safeParse(config);
+      if (!parseResult.success) {
+        logger3.error("Storage config validation failed", { error: parseResult.error.message });
+        return err(
+          HaiStorageError.CONFIG_ERROR,
+          storageM("storage_configError", { params: { error: parseResult.error.message } }),
+          parseResult.error
+        );
+      }
+      const parsed = parseResult.data;
+      const provider = createProvider(parsed);
+      const connectResult = await provider.connect(parsed);
+      if (!connectResult.success) {
+        logger3.error("Storage module initialization failed", {
+          code: connectResult.error.code,
+          message: connectResult.error.message
+        });
+        return connectResult;
+      }
+      currentProvider = provider;
+      currentConfig = parsed;
+      logger3.info("Storage module initialized");
+      return ok(void 0);
+    } catch (error) {
+      logger3.error("Storage module initialization failed", { error });
+      return err(
+        HaiStorageError.CONNECTION_FAILED,
+        storageM("storage_operationFailed", {
+          params: { error: error instanceof Error ? error.message : String(error) }
+        }),
+        error
+      );
+    } finally {
+      initInProgress = false;
+    }
+  },
+  /** 文件操作接口。未初始化时所有方法返回 NOT_INITIALIZED 错误 */
+  get file() {
+    return currentProvider?.file ?? notInitializedFile;
+  },
+  /** 目录操作接口。未初始化时所有方法返回 NOT_INITIALIZED 错误 */
+  get dir() {
+    return currentProvider?.dir ?? notInitializedDir;
+  },
+  /** 签名 URL 操作接口。未初始化时 publicUrl 返回 null，其余返回错误 */
+  get presign() {
+    return currentProvider?.presign ?? notInitializedPresign;
+  },
+  /** 当前解析后的存储配置；未初始化或已关闭时为 null */
+  get config() {
+    return currentConfig;
+  },
+  /** 是否已完成初始化 */
+  get isInitialized() {
+    return currentProvider !== null;
+  },
+  /**
+   * 关闭存储连接并释放资源
+   *
+   * 关闭后 file/dir/presign 操作将返回 NOT_INITIALIZED 错误。
+   * 重复调用不会报错。
+   */
+  async close() {
+    if (!currentProvider) {
+      currentConfig = null;
+      logger3.info("Storage module already closed, skipping");
+      return;
+    }
+    logger3.info("Closing storage module");
+    try {
+      await currentProvider.close();
+      logger3.info("Storage module closed");
+    } catch (error) {
+      logger3.error("Storage module close failed", { error });
+    } finally {
+      currentProvider = null;
+      currentConfig = null;
+    }
+  }
+};
+
+export { storage };
+//# sourceMappingURL=node.js.map
+//# sourceMappingURL=node.js.map