hazo_files 1.0.0

package/dist/index.js

@@ -0,0 +1,2457 @@
+"use strict";
+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, {
+  ALL_SYSTEM_VARIABLES: () => ALL_SYSTEM_VARIABLES,
+  AuthenticationError: () => AuthenticationError,
+  ConfigurationError: () => ConfigurationError,
+  DEFAULT_DATE_FORMATS: () => DEFAULT_DATE_FORMATS,
+  DirectoryExistsError: () => DirectoryExistsError,
+  DirectoryNotEmptyError: () => DirectoryNotEmptyError,
+  DirectoryNotFoundError: () => DirectoryNotFoundError,
+  FileExistsError: () => FileExistsError,
+  FileManager: () => FileManager,
+  FileNotFoundError: () => FileNotFoundError,
+  FileTooLargeError: () => FileTooLargeError,
+  GoogleDriveAuth: () => GoogleDriveAuth,
+  GoogleDriveModule: () => GoogleDriveModule,
+  HazoFilesError: () => HazoFilesError,
+  InvalidExtensionError: () => InvalidExtensionError,
+  InvalidPathError: () => InvalidPathError,
+  LocalStorageModule: () => LocalStorageModule,
+  OperationError: () => OperationError,
+  PermissionDeniedError: () => PermissionDeniedError,
+  SYSTEM_COUNTER_VARIABLES: () => SYSTEM_COUNTER_VARIABLES,
+  SYSTEM_DATE_VARIABLES: () => SYSTEM_DATE_VARIABLES,
+  SYSTEM_FILE_VARIABLES: () => SYSTEM_FILE_VARIABLES,
+  clonePattern: () => clonePattern,
+  createAndInitializeModule: () => createAndInitializeModule,
+  createEmptyNamingRuleSchema: () => createEmptyNamingRuleSchema,
+  createFileItem: () => createFileItem,
+  createFileManager: () => createFileManager,
+  createFolderItem: () => createFolderItem,
+  createGoogleDriveAuth: () => createGoogleDriveAuth,
+  createGoogleDriveModule: () => createGoogleDriveModule,
+  createInitializedFileManager: () => createInitializedFileManager,
+  createLiteralSegment: () => createLiteralSegment,
+  createLocalModule: () => createLocalModule,
+  createModule: () => createModule,
+  createVariableSegment: () => createVariableSegment,
+  errorResult: () => errorResult,
+  filterItems: () => filterItems,
+  formatBytes: () => formatBytes,
+  formatCounter: () => formatCounter,
+  formatDateToken: () => formatDateToken,
+  generateId: () => generateId,
+  generatePreviewName: () => generatePreviewName,
+  generateSampleConfig: () => generateSampleConfig,
+  generateSegmentId: () => generateSegmentId,
+  getBaseName: () => getBaseName,
+  getBreadcrumbs: () => getBreadcrumbs,
+  getDirName: () => getDirName,
+  getExtension: () => getExtension,
+  getExtensionFromMime: () => getExtensionFromMime,
+  getFileCategory: () => getFileCategory,
+  getFileMetadataValues: () => getFileMetadataValues,
+  getMimeType: () => getMimeType,
+  getNameWithoutExtension: () => getNameWithoutExtension,
+  getParentPath: () => getParentPath,
+  getPathSegments: () => getPathSegments,
+  getRegisteredProviders: () => getRegisteredProviders,
+  getRelativePath: () => getRelativePath,
+  getSystemVariablePreviewValues: () => getSystemVariablePreviewValues,
+  hasExtension: () => hasExtension,
+  hazo_files_generate_file_name: () => hazo_files_generate_file_name,
+  hazo_files_generate_folder_name: () => hazo_files_generate_folder_name,
+  isAudio: () => isAudio,
+  isChildPath: () => isChildPath,
+  isCounterVariable: () => isCounterVariable,
+  isDateVariable: () => isDateVariable,
+  isDocument: () => isDocument,
+  isFile: () => isFile,
+  isFileMetadataVariable: () => isFileMetadataVariable,
+  isFolder: () => isFolder,
+  isImage: () => isImage,
+  isPreviewable: () => isPreviewable,
+  isProviderRegistered: () => isProviderRegistered,
+  isText: () => isText,
+  isVideo: () => isVideo,
+  joinPath: () => joinPath,
+  loadConfig: () => loadConfig,
+  loadConfigAsync: () => loadConfigAsync,
+  normalizePath: () => normalizePath,
+  parseConfig: () => parseConfig,
+  parsePatternString: () => parsePatternString,
+  patternToString: () => patternToString,
+  registerModule: () => registerModule,
+  sanitizeFilename: () => sanitizeFilename,
+  saveConfig: () => saveConfig,
+  sortItems: () => sortItems,
+  successResult: () => successResult,
+  validateNamingRuleSchema: () => validateNamingRuleSchema,
+  validatePath: () => validatePath
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/config/index.ts
+var ini = __toESM(require("ini"));
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var DEFAULT_CONFIG_FILENAME = "hazo_files_config.ini";
+function parseConfig(configContent) {
+  const parsed = ini.parse(configContent);
+  const provider = parsed.general?.provider || "local";
+  const config = {
+    provider
+  };
+  if (parsed.local) {
+    config.local = {
+      basePath: parsed.local.base_path || "./files",
+      allowedExtensions: parsed.local.allowed_extensions ? parsed.local.allowed_extensions.split(",").map((ext) => ext.trim()) : void 0,
+      maxFileSize: parsed.local.max_file_size ? parseInt(parsed.local.max_file_size, 10) : void 0
+    };
+  }
+  if (parsed.google_drive) {
+    config.google_drive = {
+      clientId: parsed.google_drive.client_id || process.env.GOOGLE_DRIVE_CLIENT_ID || "",
+      clientSecret: parsed.google_drive.client_secret || process.env.GOOGLE_DRIVE_CLIENT_SECRET || "",
+      redirectUri: parsed.google_drive.redirect_uri || process.env.GOOGLE_DRIVE_REDIRECT_URI || "",
+      refreshToken: parsed.google_drive.refresh_token || process.env.GOOGLE_DRIVE_REFRESH_TOKEN,
+      accessToken: parsed.google_drive.access_token || process.env.GOOGLE_DRIVE_ACCESS_TOKEN,
+      rootFolderId: parsed.google_drive.root_folder_id || process.env.GOOGLE_DRIVE_ROOT_FOLDER_ID
+    };
+  }
+  return config;
+}
+function loadConfig(configPath) {
+  const resolvedPath = configPath || path.join(process.cwd(), DEFAULT_CONFIG_FILENAME);
+  if (!fs.existsSync(resolvedPath)) {
+    console.warn(`Config file not found at ${resolvedPath}, using defaults`);
+    return {
+      provider: "local",
+      local: {
+        basePath: "./files"
+      }
+    };
+  }
+  const content = fs.readFileSync(resolvedPath, "utf-8");
+  return parseConfig(content);
+}
+async function loadConfigAsync(configPath) {
+  const resolvedPath = configPath || path.join(process.cwd(), DEFAULT_CONFIG_FILENAME);
+  try {
+    const content = await fs.promises.readFile(resolvedPath, "utf-8");
+    return parseConfig(content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      console.warn(`Config file not found at ${resolvedPath}, using defaults`);
+      return {
+        provider: "local",
+        local: {
+          basePath: "./files"
+        }
+      };
+    }
+    throw error;
+  }
+}
+function generateSampleConfig() {
+  return `; Hazo Files Configuration
+; This file configures the file management system
+
+[general]
+; Available providers: local, google_drive
+provider = local
+
+[local]
+; Base path for local file storage (relative or absolute)
+base_path = ./files
+; Comma-separated list of allowed extensions (optional, empty = all allowed)
+allowed_extensions =
+; Maximum file size in bytes (optional, 0 = unlimited)
+max_file_size = 0
+
+[google_drive]
+; Google Drive OAuth credentials
+; These can also be set via environment variables:
+; GOOGLE_DRIVE_CLIENT_ID, GOOGLE_DRIVE_CLIENT_SECRET, etc.
+client_id =
+client_secret =
+redirect_uri = http://localhost:3000/api/auth/callback/google
+refresh_token =
+access_token =
+; Optional: Root folder ID to use as base (empty = root of Drive)
+root_folder_id =
+`;
+}
+async function saveConfig(config, configPath) {
+  const resolvedPath = configPath || path.join(process.cwd(), DEFAULT_CONFIG_FILENAME);
+  const iniConfig = {
+    general: {
+      provider: config.provider
+    }
+  };
+  if (config.local) {
+    iniConfig.local = {
+      base_path: config.local.basePath,
+      allowed_extensions: config.local.allowedExtensions?.join(", ") || "",
+      max_file_size: config.local.maxFileSize?.toString() || "0"
+    };
+  }
+  if (config.google_drive) {
+    iniConfig.google_drive = {
+      client_id: config.google_drive.clientId || "",
+      client_secret: config.google_drive.clientSecret || "",
+      redirect_uri: config.google_drive.redirectUri || "",
+      refresh_token: config.google_drive.refreshToken || "",
+      access_token: config.google_drive.accessToken || "",
+      root_folder_id: config.google_drive.rootFolderId || ""
+    };
+  }
+  const content = ini.stringify(iniConfig);
+  await fs.promises.writeFile(resolvedPath, content, "utf-8");
+}
+
+// src/modules/local/index.ts
+var fs2 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var import_stream = require("stream");
+var import_promises = require("stream/promises");
+
+// src/common/errors.ts
+var HazoFilesError = class extends Error {
+  constructor(message, code, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "HazoFilesError";
+  }
+};
+var FileNotFoundError = class extends HazoFilesError {
+  constructor(path3) {
+    super(`File not found: ${path3}`, "FILE_NOT_FOUND", { path: path3 });
+    this.name = "FileNotFoundError";
+  }
+};
+var DirectoryNotFoundError = class extends HazoFilesError {
+  constructor(path3) {
+    super(`Directory not found: ${path3}`, "DIRECTORY_NOT_FOUND", { path: path3 });
+    this.name = "DirectoryNotFoundError";
+  }
+};
+var FileExistsError = class extends HazoFilesError {
+  constructor(path3) {
+    super(`File already exists: ${path3}`, "FILE_EXISTS", { path: path3 });
+    this.name = "FileExistsError";
+  }
+};
+var DirectoryExistsError = class extends HazoFilesError {
+  constructor(path3) {
+    super(`Directory already exists: ${path3}`, "DIRECTORY_EXISTS", { path: path3 });
+    this.name = "DirectoryExistsError";
+  }
+};
+var DirectoryNotEmptyError = class extends HazoFilesError {
+  constructor(path3) {
+    super(`Directory is not empty: ${path3}`, "DIRECTORY_NOT_EMPTY", { path: path3 });
+    this.name = "DirectoryNotEmptyError";
+  }
+};
+var PermissionDeniedError = class extends HazoFilesError {
+  constructor(path3, operation) {
+    super(`Permission denied for ${operation} on: ${path3}`, "PERMISSION_DENIED", { path: path3, operation });
+    this.name = "PermissionDeniedError";
+  }
+};
+var InvalidPathError = class extends HazoFilesError {
+  constructor(path3, reason) {
+    super(`Invalid path "${path3}": ${reason}`, "INVALID_PATH", { path: path3, reason });
+    this.name = "InvalidPathError";
+  }
+};
+var FileTooLargeError = class extends HazoFilesError {
+  constructor(path3, size, maxSize) {
+    super(
+      `File "${path3}" is too large (${size} bytes). Maximum allowed: ${maxSize} bytes`,
+      "FILE_TOO_LARGE",
+      { path: path3, size, maxSize }
+    );
+    this.name = "FileTooLargeError";
+  }
+};
+var InvalidExtensionError = class extends HazoFilesError {
+  constructor(path3, extension, allowedExtensions) {
+    super(
+      `File extension "${extension}" is not allowed. Allowed: ${allowedExtensions.join(", ")}`,
+      "INVALID_EXTENSION",
+      { path: path3, extension, allowedExtensions }
+    );
+    this.name = "InvalidExtensionError";
+  }
+};
+var AuthenticationError = class extends HazoFilesError {
+  constructor(provider, message) {
+    super(`Authentication failed for ${provider}: ${message}`, "AUTHENTICATION_ERROR", { provider });
+    this.name = "AuthenticationError";
+  }
+};
+var ConfigurationError = class extends HazoFilesError {
+  constructor(message) {
+    super(`Configuration error: ${message}`, "CONFIGURATION_ERROR");
+    this.name = "ConfigurationError";
+  }
+};
+var OperationError = class extends HazoFilesError {
+  constructor(operation, message, details) {
+    super(`${operation} failed: ${message}`, "OPERATION_ERROR", details);
+    this.name = "OperationError";
+  }
+};
+
+// src/common/utils.ts
+function successResult(data) {
+  return {
+    success: true,
+    data
+  };
+}
+function errorResult(error) {
+  return {
+    success: false,
+    error
+  };
+}
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+}
+function formatBytes(bytes, decimals = 2) {
+  if (bytes === 0) return "0 Bytes";
+  const k = 1024;
+  const dm = decimals < 0 ? 0 : decimals;
+  const sizes = ["Bytes", "KB", "MB", "GB", "TB", "PB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + " " + sizes[i];
+}
+function isFile(item) {
+  return !item.isDirectory;
+}
+function isFolder(item) {
+  return item.isDirectory;
+}
+function sortItems(items) {
+  return [...items].sort((a, b) => {
+    if (a.isDirectory && !b.isDirectory) return -1;
+    if (!a.isDirectory && b.isDirectory) return 1;
+    return a.name.localeCompare(b.name);
+  });
+}
+function filterItems(items, searchTerm) {
+  const term = searchTerm.toLowerCase();
+  return items.filter((item) => item.name.toLowerCase().includes(term));
+}
+function createFileItem(params) {
+  return {
+    id: params.id,
+    name: params.name,
+    path: params.path,
+    size: params.size,
+    mimeType: params.mimeType,
+    createdAt: params.createdAt || /* @__PURE__ */ new Date(),
+    modifiedAt: params.modifiedAt || /* @__PURE__ */ new Date(),
+    isDirectory: false,
+    parentId: params.parentId,
+    metadata: params.metadata
+  };
+}
+function createFolderItem(params) {
+  return {
+    id: params.id,
+    name: params.name,
+    path: params.path,
+    createdAt: params.createdAt || /* @__PURE__ */ new Date(),
+    modifiedAt: params.modifiedAt || /* @__PURE__ */ new Date(),
+    isDirectory: true,
+    parentId: params.parentId,
+    children: params.children,
+    metadata: params.metadata
+  };
+}
+
+// src/common/path-utils.ts
+function normalizePath(inputPath) {
+  if (!inputPath) return "/";
+  let normalized = inputPath.replace(/\\/g, "/");
+  normalized = normalized.replace(/\/+/g, "/");
+  const parts = normalized.split("/");
+  const result = [];
+  for (const part of parts) {
+    if (part === "." || part === "") continue;
+    if (part === "..") {
+      result.pop();
+    } else {
+      result.push(part);
+    }
+  }
+  normalized = "/" + result.join("/");
+  return normalized;
+}
+function joinPath(...segments) {
+  const joined = segments.map((s) => s.replace(/^\/+|\/+$/g, "")).filter(Boolean).join("/");
+  return normalizePath("/" + joined);
+}
+function getParentPath(inputPath) {
+  const normalized = normalizePath(inputPath);
+  if (normalized === "/") return "/";
+  const lastSlash = normalized.lastIndexOf("/");
+  if (lastSlash === 0) return "/";
+  return normalized.slice(0, lastSlash) || "/";
+}
+function getBaseName(inputPath) {
+  const normalized = normalizePath(inputPath);
+  if (normalized === "/") return "";
+  const lastSlash = normalized.lastIndexOf("/");
+  return normalized.slice(lastSlash + 1);
+}
+function getDirName(inputPath) {
+  return getParentPath(inputPath);
+}
+function getPathSegments(inputPath) {
+  const normalized = normalizePath(inputPath);
+  if (normalized === "/") return [];
+  return normalized.slice(1).split("/");
+}
+function isChildPath(parentPath, childPath) {
+  const normalizedParent = normalizePath(parentPath);
+  const normalizedChild = normalizePath(childPath);
+  if (normalizedParent === "/") {
+    return normalizedChild !== "/";
+  }
+  return normalizedChild.startsWith(normalizedParent + "/");
+}
+function getRelativePath(basePath, targetPath) {
+  const baseSegments = getPathSegments(basePath);
+  const targetSegments = getPathSegments(targetPath);
+  let commonLength = 0;
+  while (commonLength < baseSegments.length && commonLength < targetSegments.length && baseSegments[commonLength] === targetSegments[commonLength]) {
+    commonLength++;
+  }
+  const upCount = baseSegments.length - commonLength;
+  const remaining = targetSegments.slice(commonLength);
+  const parts = [];
+  for (let i = 0; i < upCount; i++) {
+    parts.push("..");
+  }
+  parts.push(...remaining);
+  return parts.join("/") || ".";
+}
+function validatePath(inputPath, basePath) {
+  normalizePath(inputPath);
+  if (inputPath.includes("\0")) {
+    throw new InvalidPathError(inputPath, "Path contains null bytes");
+  }
+  if (basePath) {
+    const normalizedBase = normalizePath(basePath);
+    const fullPath = joinPath(normalizedBase, inputPath);
+    if (!fullPath.startsWith(normalizedBase)) {
+      throw new InvalidPathError(inputPath, "Path traversal detected");
+    }
+  }
+}
+function sanitizeFilename(filename) {
+  let sanitized = filename.replace(/[<>:"/\\|?*\x00-\x1F]/g, "_").replace(/^\.+/, "").trim();
+  if (!sanitized) {
+    sanitized = "unnamed";
+  }
+  if (sanitized.length > 255) {
+    const ext = getExtension(sanitized);
+    const name = sanitized.slice(0, 255 - ext.length);
+    sanitized = name + ext;
+  }
+  return sanitized;
+}
+function getExtension(filename) {
+  const lastDot = filename.lastIndexOf(".");
+  if (lastDot === -1 || lastDot === 0) return "";
+  return filename.slice(lastDot);
+}
+function getNameWithoutExtension(filename) {
+  const lastDot = filename.lastIndexOf(".");
+  if (lastDot === -1 || lastDot === 0) return filename;
+  return filename.slice(0, lastDot);
+}
+function hasExtension(filename, extension) {
+  const ext = getExtension(filename).toLowerCase();
+  const targetExt = extension.startsWith(".") ? extension.toLowerCase() : "." + extension.toLowerCase();
+  return ext === targetExt;
+}
+function getBreadcrumbs(inputPath) {
+  const segments = getPathSegments(inputPath);
+  const breadcrumbs = [
+    { name: "Root", path: "/" }
+  ];
+  let currentPath = "";
+  for (const segment of segments) {
+    currentPath += "/" + segment;
+    breadcrumbs.push({
+      name: segment,
+      path: currentPath
+    });
+  }
+  return breadcrumbs;
+}
+
+// src/common/base-module.ts
+var BaseStorageModule = class {
+  constructor() {
+    this.config = null;
+    this._initialized = false;
+    // Utility methods available to subclasses
+    this.normalizePath = normalizePath;
+    this.joinPath = joinPath;
+    this.getBaseName = getBaseName;
+    this.getParentPath = getParentPath;
+    this.successResult = successResult;
+    this.errorResult = errorResult;
+  }
+  /**
+   * Check if the module is initialized
+   */
+  get isInitialized() {
+    return this._initialized;
+  }
+  /**
+   * Initialize the module with configuration.
+   * Subclasses should call super.initialize(config) first.
+   */
+  async initialize(config) {
+    this.config = config;
+    this._initialized = true;
+  }
+  /**
+   * Ensure the module is initialized before operations
+   */
+  ensureInitialized() {
+    if (!this._initialized || !this.config) {
+      throw new ConfigurationError("Module not initialized. Call initialize() first.");
+    }
+  }
+  /**
+   * Get the provider-specific configuration
+   */
+  getProviderConfig() {
+    this.ensureInitialized();
+    const providerConfig = this.config[this.provider];
+    if (!providerConfig) {
+      throw new ConfigurationError(`No configuration found for provider: ${this.provider}`);
+    }
+    return providerConfig;
+  }
+  /**
+   * Get folder tree structure.
+   * Default implementation that can be overridden by subclasses for optimization.
+   */
+  async getFolderTree(path3 = "/", depth = 3) {
+    this.ensureInitialized();
+    try {
+      const result = await this.buildTree(path3, depth, 0);
+      return successResult(result);
+    } catch (error) {
+      return errorResult(`Failed to get folder tree: ${error.message}`);
+    }
+  }
+  /**
+   * Recursively build folder tree
+   */
+  async buildTree(path3, maxDepth, currentDepth) {
+    if (currentDepth >= maxDepth) {
+      return [];
+    }
+    const listResult = await this.listDirectory(path3, { recursive: false });
+    if (!listResult.success || !listResult.data) {
+      return [];
+    }
+    const folders = listResult.data.filter((item) => item.isDirectory);
+    const nodes = [];
+    for (const folder of folders) {
+      const children = await this.buildTree(folder.path, maxDepth, currentDepth + 1);
+      nodes.push({
+        id: folder.id,
+        name: folder.name,
+        path: folder.path,
+        children
+      });
+    }
+    return nodes;
+  }
+};
+
+// src/common/mime-types.ts
+var MIME_TYPES = {
+  // Text
+  ".txt": "text/plain",
+  ".html": "text/html",
+  ".htm": "text/html",
+  ".css": "text/css",
+  ".csv": "text/csv",
+  ".xml": "text/xml",
+  ".json": "application/json",
+  ".js": "application/javascript",
+  ".ts": "application/typescript",
+  ".jsx": "text/jsx",
+  ".tsx": "text/tsx",
+  ".md": "text/markdown",
+  ".yaml": "text/yaml",
+  ".yml": "text/yaml",
+  // Images
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".gif": "image/gif",
+  ".bmp": "image/bmp",
+  ".webp": "image/webp",
+  ".svg": "image/svg+xml",
+  ".ico": "image/x-icon",
+  // Documents
+  ".pdf": "application/pdf",
+  ".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",
+  // Archives
+  ".zip": "application/zip",
+  ".rar": "application/x-rar-compressed",
+  ".7z": "application/x-7z-compressed",
+  ".tar": "application/x-tar",
+  ".gz": "application/gzip",
+  // Audio
+  ".mp3": "audio/mpeg",
+  ".wav": "audio/wav",
+  ".ogg": "audio/ogg",
+  ".m4a": "audio/mp4",
+  ".flac": "audio/flac",
+  // Video
+  ".mp4": "video/mp4",
+  ".webm": "video/webm",
+  ".avi": "video/x-msvideo",
+  ".mov": "video/quicktime",
+  ".wmv": "video/x-ms-wmv",
+  ".mkv": "video/x-matroska",
+  // Fonts
+  ".ttf": "font/ttf",
+  ".otf": "font/otf",
+  ".woff": "font/woff",
+  ".woff2": "font/woff2",
+  // Other
+  ".exe": "application/x-msdownload",
+  ".dmg": "application/x-apple-diskimage",
+  ".bin": "application/octet-stream"
+};
+var EXTENSION_BY_MIME = Object.entries(MIME_TYPES).reduce(
+  (acc, [ext, mime]) => {
+    if (!acc[mime]) {
+      acc[mime] = ext;
+    }
+    return acc;
+  },
+  {}
+);
+function getMimeType(filename) {
+  const ext = getExtension(filename).toLowerCase();
+  return MIME_TYPES[ext] || "application/octet-stream";
+}
+function getExtensionFromMime(mimeType) {
+  return EXTENSION_BY_MIME[mimeType] || "";
+}
+function isImage(filenameOrMime) {
+  const mime = filenameOrMime.includes("/") ? filenameOrMime : getMimeType(filenameOrMime);
+  return mime.startsWith("image/");
+}
+function isVideo(filenameOrMime) {
+  const mime = filenameOrMime.includes("/") ? filenameOrMime : getMimeType(filenameOrMime);
+  return mime.startsWith("video/");
+}
+function isAudio(filenameOrMime) {
+  const mime = filenameOrMime.includes("/") ? filenameOrMime : getMimeType(filenameOrMime);
+  return mime.startsWith("audio/");
+}
+function isText(filenameOrMime) {
+  const mime = filenameOrMime.includes("/") ? filenameOrMime : getMimeType(filenameOrMime);
+  return mime.startsWith("text/") || mime === "application/json" || mime === "application/javascript";
+}
+function isDocument(filenameOrMime) {
+  const mime = filenameOrMime.includes("/") ? filenameOrMime : getMimeType(filenameOrMime);
+  return mime === "application/pdf" || mime.includes("document") || mime.includes("spreadsheet") || mime.includes("presentation");
+}
+function isPreviewable(filenameOrMime) {
+  return isImage(filenameOrMime) || isText(filenameOrMime) || isVideo(filenameOrMime) || isAudio(filenameOrMime);
+}
+function getFileCategory(filenameOrMime) {
+  if (isImage(filenameOrMime)) return "image";
+  if (isVideo(filenameOrMime)) return "video";
+  if (isAudio(filenameOrMime)) return "audio";
+  if (isDocument(filenameOrMime)) return "document";
+  if (isText(filenameOrMime)) return "text";
+  return "other";
+}
+
+// src/modules/local/index.ts
+var LocalStorageModule = class extends BaseStorageModule {
+  constructor() {
+    super(...arguments);
+    this.provider = "local";
+    this.basePath = "";
+    this.allowedExtensions = [];
+    this.maxFileSize = 0;
+  }
+  async initialize(config) {
+    await super.initialize(config);
+    const localConfig = this.getProviderConfig();
+    this.basePath = path2.resolve(localConfig.basePath);
+    this.allowedExtensions = localConfig.allowedExtensions || [];
+    this.maxFileSize = localConfig.maxFileSize || 0;
+    await fs2.promises.mkdir(this.basePath, { recursive: true });
+  }
+  /**
+   * Resolve a virtual path to an absolute file system path
+   */
+  resolveFullPath(virtualPath) {
+    const normalized = this.normalizePath(virtualPath);
+    const relativePath = normalized.startsWith("/") ? normalized.slice(1) : normalized;
+    return path2.join(this.basePath, relativePath);
+  }
+  /**
+   * Convert absolute path back to virtual path
+   */
+  toVirtualPath(absolutePath) {
+    const relative2 = path2.relative(this.basePath, absolutePath);
+    return this.normalizePath("/" + relative2.replace(/\\/g, "/"));
+  }
+  /**
+   * Validate file extension against allowed list
+   */
+  validateExtension(filename) {
+    if (this.allowedExtensions.length === 0) return;
+    const ext = getExtension(filename).toLowerCase().slice(1);
+    if (!this.allowedExtensions.includes(ext)) {
+      throw new InvalidExtensionError(filename, ext, this.allowedExtensions);
+    }
+  }
+  /**
+   * Validate file size against maximum
+   */
+  validateFileSize(size, filename) {
+    if (this.maxFileSize > 0 && size > this.maxFileSize) {
+      throw new FileTooLargeError(filename, size, this.maxFileSize);
+    }
+  }
+  /**
+   * Create file/folder stats to FileSystemItem
+   */
+  async statToItem(fullPath, stats) {
+    const virtualPath = this.toVirtualPath(fullPath);
+    const name = path2.basename(fullPath);
+    const id = generateId();
+    if (stats.isDirectory()) {
+      return createFolderItem({
+        id,
+        name,
+        path: virtualPath,
+        createdAt: stats.birthtime,
+        modifiedAt: stats.mtime
+      });
+    }
+    return createFileItem({
+      id,
+      name,
+      path: virtualPath,
+      size: stats.size,
+      mimeType: getMimeType(name),
+      createdAt: stats.birthtime,
+      modifiedAt: stats.mtime
+    });
+  }
+  async createDirectory(virtualPath) {
+    this.ensureInitialized();
+    try {
+      const fullPath = this.resolveFullPath(virtualPath);
+      try {
+        const stats2 = await fs2.promises.stat(fullPath);
+        if (stats2.isDirectory()) {
+          throw new DirectoryExistsError(virtualPath);
+        }
+        throw new FileExistsError(virtualPath);
+      } catch (error) {
+        if (error.code !== "ENOENT") {
+          throw error;
+        }
+      }
+      await fs2.promises.mkdir(fullPath, { recursive: true });
+      const stats = await fs2.promises.stat(fullPath);
+      const item = await this.statToItem(fullPath, stats);
+      return this.successResult(item);
+    } catch (error) {
+      if (error instanceof DirectoryExistsError || error instanceof FileExistsError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to create directory: ${error.message}`);
+    }
+  }
+  async removeDirectory(virtualPath, recursive = false) {
+    this.ensureInitialized();
+    try {
+      const fullPath = this.resolveFullPath(virtualPath);
+      const stats = await fs2.promises.stat(fullPath).catch(() => null);
+      if (!stats) {
+        throw new DirectoryNotFoundError(virtualPath);
+      }
+      if (!stats.isDirectory()) {
+        throw new DirectoryNotFoundError(virtualPath);
+      }
+      if (!recursive) {
+        const contents = await fs2.promises.readdir(fullPath);
+        if (contents.length > 0) {
+          throw new DirectoryNotEmptyError(virtualPath);
+        }
+      }
+      await fs2.promises.rm(fullPath, { recursive, force: true });
+      return this.successResult();
+    } catch (error) {
+      if (error instanceof DirectoryNotFoundError || error instanceof DirectoryNotEmptyError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to remove directory: ${error.message}`);
+    }
+  }
+  async uploadFile(source, remotePath, options = {}) {
+    this.ensureInitialized();
+    try {
+      const fullPath = this.resolveFullPath(remotePath);
+      const filename = path2.basename(fullPath);
+      this.validateExtension(filename);
+      if (!options.overwrite) {
+        try {
+          await fs2.promises.stat(fullPath);
+          throw new FileExistsError(remotePath);
+        } catch (error) {
+          if (error.code !== "ENOENT") {
+            if (error instanceof FileExistsError) throw error;
+          }
+        }
+      }
+      const parentDir = path2.dirname(fullPath);
+      await fs2.promises.mkdir(parentDir, { recursive: true });
+      if (typeof source === "string") {
+        const stats2 = await fs2.promises.stat(source);
+        this.validateFileSize(stats2.size, filename);
+        if (options.onProgress) {
+          const totalBytes = stats2.size;
+          let bytesTransferred = 0;
+          const readStream = fs2.createReadStream(source);
+          const writeStream = fs2.createWriteStream(fullPath);
+          readStream.on("data", (chunk) => {
+            bytesTransferred += chunk.length;
+            const progress = bytesTransferred / totalBytes * 100;
+            options.onProgress(progress, bytesTransferred, totalBytes);
+          });
+          await (0, import_promises.pipeline)(readStream, writeStream);
+        } else {
+          await fs2.promises.copyFile(source, fullPath);
+        }
+      } else if (Buffer.isBuffer(source)) {
+        this.validateFileSize(source.length, filename);
+        await fs2.promises.writeFile(fullPath, source);
+        if (options.onProgress) {
+          options.onProgress(100, source.length, source.length);
+        }
+      } else {
+        const writeStream = fs2.createWriteStream(fullPath);
+        const readable = import_stream.Readable.fromWeb(source);
+        await (0, import_promises.pipeline)(readable, writeStream);
+      }
+      const stats = await fs2.promises.stat(fullPath);
+      const item = await this.statToItem(fullPath, stats);
+      return this.successResult(item);
+    } catch (error) {
+      if (error instanceof FileExistsError || error instanceof FileTooLargeError || error instanceof InvalidExtensionError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to upload file: ${error.message}`);
+    }
+  }
+  async downloadFile(remotePath, localPath, options = {}) {
+    this.ensureInitialized();
+    try {
+      const fullPath = this.resolveFullPath(remotePath);
+      const stats = await fs2.promises.stat(fullPath).catch(() => null);
+      if (!stats || stats.isDirectory()) {
+        throw new FileNotFoundError(remotePath);
+      }
+      if (localPath) {
+        const destDir = path2.dirname(localPath);
+        await fs2.promises.mkdir(destDir, { recursive: true });
+        if (options.onProgress) {
+          const totalBytes = stats.size;
+          let bytesTransferred = 0;
+          const readStream = fs2.createReadStream(fullPath);
+          const writeStream = fs2.createWriteStream(localPath);
+          readStream.on("data", (chunk) => {
+            bytesTransferred += chunk.length;
+            const progress = bytesTransferred / totalBytes * 100;
+            options.onProgress(progress, bytesTransferred, totalBytes);
+          });
+          await (0, import_promises.pipeline)(readStream, writeStream);
+        } else {
+          await fs2.promises.copyFile(fullPath, localPath);
+        }
+        return this.successResult(localPath);
+      } else {
+        const buffer = await fs2.promises.readFile(fullPath);
+        if (options.onProgress) {
+          options.onProgress(100, buffer.length, buffer.length);
+        }
+        return this.successResult(buffer);
+      }
+    } catch (error) {
+      if (error instanceof FileNotFoundError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to download file: ${error.message}`);
+    }
+  }
+  async moveItem(sourcePath, destinationPath, options = {}) {
+    this.ensureInitialized();
+    try {
+      const sourceFullPath = this.resolveFullPath(sourcePath);
+      const destFullPath = this.resolveFullPath(destinationPath);
+      const sourceStats = await fs2.promises.stat(sourceFullPath).catch(() => null);
+      if (!sourceStats) {
+        throw new FileNotFoundError(sourcePath);
+      }
+      if (!options.overwrite) {
+        const destStats = await fs2.promises.stat(destFullPath).catch(() => null);
+        if (destStats) {
+          throw new FileExistsError(destinationPath);
+        }
+      }
+      const destParent = path2.dirname(destFullPath);
+      await fs2.promises.mkdir(destParent, { recursive: true });
+      await fs2.promises.rename(sourceFullPath, destFullPath);
+      const newStats = await fs2.promises.stat(destFullPath);
+      const item = await this.statToItem(destFullPath, newStats);
+      return this.successResult(item);
+    } catch (error) {
+      if (error instanceof FileNotFoundError || error instanceof FileExistsError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to move item: ${error.message}`);
+    }
+  }
+  async deleteFile(virtualPath) {
+    this.ensureInitialized();
+    try {
+      const fullPath = this.resolveFullPath(virtualPath);
+      const stats = await fs2.promises.stat(fullPath).catch(() => null);
+      if (!stats) {
+        throw new FileNotFoundError(virtualPath);
+      }
+      if (stats.isDirectory()) {
+        throw new FileNotFoundError(virtualPath);
+      }
+      await fs2.promises.unlink(fullPath);
+      return this.successResult();
+    } catch (error) {
+      if (error instanceof FileNotFoundError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to delete file: ${error.message}`);
+    }
+  }
+  async renameFile(virtualPath, newName, options = {}) {
+    this.ensureInitialized();
+    try {
+      const fullPath = this.resolveFullPath(virtualPath);
+      const stats = await fs2.promises.stat(fullPath).catch(() => null);
+      if (!stats || stats.isDirectory()) {
+        throw new FileNotFoundError(virtualPath);
+      }
+      this.validateExtension(newName);
+      const parentDir = path2.dirname(fullPath);
+      const newFullPath = path2.join(parentDir, newName);
+      if (!options.overwrite) {
+        const destStats = await fs2.promises.stat(newFullPath).catch(() => null);
+        if (destStats) {
+          throw new FileExistsError(newName);
+        }
+      }
+      await fs2.promises.rename(fullPath, newFullPath);
+      const newStats = await fs2.promises.stat(newFullPath);
+      const item = await this.statToItem(newFullPath, newStats);
+      return this.successResult(item);
+    } catch (error) {
+      if (error instanceof FileNotFoundError || error instanceof FileExistsError || error instanceof InvalidExtensionError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to rename file: ${error.message}`);
+    }
+  }
+  async renameFolder(virtualPath, newName, options = {}) {
+    this.ensureInitialized();
+    try {
+      const fullPath = this.resolveFullPath(virtualPath);
+      const stats = await fs2.promises.stat(fullPath).catch(() => null);
+      if (!stats || !stats.isDirectory()) {
+        throw new DirectoryNotFoundError(virtualPath);
+      }
+      const parentDir = path2.dirname(fullPath);
+      const newFullPath = path2.join(parentDir, newName);
+      if (!options.overwrite) {
+        const destStats = await fs2.promises.stat(newFullPath).catch(() => null);
+        if (destStats) {
+          throw new DirectoryExistsError(newName);
+        }
+      }
+      await fs2.promises.rename(fullPath, newFullPath);
+      const newStats = await fs2.promises.stat(newFullPath);
+      const item = await this.statToItem(newFullPath, newStats);
+      return this.successResult(item);
+    } catch (error) {
+      if (error instanceof DirectoryNotFoundError || error instanceof DirectoryExistsError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to rename folder: ${error.message}`);
+    }
+  }
+  async listDirectory(virtualPath, options = {}) {
+    this.ensureInitialized();
+    try {
+      const fullPath = this.resolveFullPath(virtualPath);
+      const stats = await fs2.promises.stat(fullPath).catch(() => null);
+      if (!stats || !stats.isDirectory()) {
+        throw new DirectoryNotFoundError(virtualPath);
+      }
+      const entries = await fs2.promises.readdir(fullPath, { withFileTypes: true });
+      const items = [];
+      for (const entry of entries) {
+        if (!options.includeHidden && entry.name.startsWith(".")) {
+          continue;
+        }
+        const entryPath = path2.join(fullPath, entry.name);
+        const entryStats = await fs2.promises.stat(entryPath);
+        const item = await this.statToItem(entryPath, entryStats);
+        if (options.filter && !options.filter(item)) {
+          continue;
+        }
+        items.push(item);
+        if (options.recursive && entry.isDirectory()) {
+          const subResult = await this.listDirectory(
+            this.toVirtualPath(entryPath),
+            options
+          );
+          if (subResult.success && subResult.data) {
+            items.push(...subResult.data);
+          }
+        }
+      }
+      items.sort((a, b) => {
+        if (a.isDirectory && !b.isDirectory) return -1;
+        if (!a.isDirectory && b.isDirectory) return 1;
+        return a.name.localeCompare(b.name);
+      });
+      return this.successResult(items);
+    } catch (error) {
+      if (error instanceof DirectoryNotFoundError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to list directory: ${error.message}`);
+    }
+  }
+  async getItem(virtualPath) {
+    this.ensureInitialized();
+    try {
+      const fullPath = this.resolveFullPath(virtualPath);
+      const stats = await fs2.promises.stat(fullPath).catch(() => null);
+      if (!stats) {
+        throw new FileNotFoundError(virtualPath);
+      }
+      const item = await this.statToItem(fullPath, stats);
+      return this.successResult(item);
+    } catch (error) {
+      if (error instanceof FileNotFoundError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to get item: ${error.message}`);
+    }
+  }
+  async exists(virtualPath) {
+    this.ensureInitialized();
+    try {
+      const fullPath = this.resolveFullPath(virtualPath);
+      await fs2.promises.stat(fullPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+function createLocalModule() {
+  return new LocalStorageModule();
+}
+
+// src/modules/google-drive/index.ts
+var import_googleapis2 = require("googleapis");
+var import_stream2 = require("stream");
+
+// src/modules/google-drive/auth.ts
+var import_googleapis = require("googleapis");
+var GOOGLE_DRIVE_SCOPES = [
+  "https://www.googleapis.com/auth/drive.file",
+  "https://www.googleapis.com/auth/drive.metadata.readonly",
+  "https://www.googleapis.com/auth/userinfo.email",
+  "https://www.googleapis.com/auth/userinfo.profile"
+];
+var GoogleDriveAuth = class {
+  constructor(config, callbacks = {}) {
+    this.tokens = null;
+    this.oauth2Client = new import_googleapis.google.auth.OAuth2(
+      config.clientId,
+      config.clientSecret,
+      config.redirectUri
+    );
+    this.callbacks = callbacks;
+    this.oauth2Client.on("tokens", async (tokens) => {
+      if (this.tokens) {
+        const updatedTokens = {
+          ...this.tokens,
+          accessToken: tokens.access_token || this.tokens.accessToken,
+          expiryDate: tokens.expiry_date ?? this.tokens.expiryDate
+        };
+        if (tokens.refresh_token) {
+          updatedTokens.refreshToken = tokens.refresh_token;
+        }
+        this.tokens = updatedTokens;
+        if (this.callbacks.onTokensUpdated) {
+          await this.callbacks.onTokensUpdated(updatedTokens);
+        }
+      }
+    });
+  }
+  /**
+   * Get the OAuth2 client instance
+   */
+  getClient() {
+    return this.oauth2Client;
+  }
+  /**
+   * Generate the authorization URL for OAuth consent
+   */
+  getAuthUrl(state) {
+    return this.oauth2Client.generateAuthUrl({
+      access_type: "offline",
+      scope: GOOGLE_DRIVE_SCOPES,
+      prompt: "consent",
+      state
+    });
+  }
+  /**
+   * Exchange authorization code for tokens
+   */
+  async exchangeCodeForTokens(code) {
+    const { tokens } = await this.oauth2Client.getToken(code);
+    this.tokens = {
+      accessToken: tokens.access_token,
+      refreshToken: tokens.refresh_token,
+      expiryDate: tokens.expiry_date || void 0,
+      scope: tokens.scope || void 0
+    };
+    this.oauth2Client.setCredentials(tokens);
+    if (this.callbacks.onTokensUpdated) {
+      await this.callbacks.onTokensUpdated(this.tokens);
+    }
+    return this.tokens;
+  }
+  /**
+   * Set tokens directly (e.g., from stored tokens)
+   */
+  async setTokens(tokens) {
+    this.tokens = tokens;
+    const credentials = {
+      access_token: tokens.accessToken,
+      refresh_token: tokens.refreshToken,
+      expiry_date: tokens.expiryDate
+    };
+    this.oauth2Client.setCredentials(credentials);
+  }
+  /**
+   * Load tokens from storage using callback
+   */
+  async loadStoredTokens() {
+    if (!this.callbacks.getStoredTokens) {
+      return false;
+    }
+    const tokens = await this.callbacks.getStoredTokens();
+    if (tokens) {
+      await this.setTokens(tokens);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Check if authenticated
+   */
+  isAuthenticated() {
+    return this.tokens !== null && !!this.tokens.accessToken;
+  }
+  /**
+   * Get current tokens
+   */
+  getTokens() {
+    return this.tokens;
+  }
+  /**
+   * Refresh the access token
+   */
+  async refreshAccessToken() {
+    if (!this.tokens?.refreshToken) {
+      throw new Error("No refresh token available");
+    }
+    const { credentials } = await this.oauth2Client.refreshAccessToken();
+    this.tokens = {
+      ...this.tokens,
+      accessToken: credentials.access_token,
+      expiryDate: credentials.expiry_date || void 0
+    };
+    if (this.callbacks.onTokensUpdated) {
+      await this.callbacks.onTokensUpdated(this.tokens);
+    }
+    return this.tokens;
+  }
+  /**
+   * Revoke access (disconnect)
+   */
+  async revokeAccess() {
+    if (this.tokens?.accessToken) {
+      await this.oauth2Client.revokeToken(this.tokens.accessToken);
+    }
+    this.tokens = null;
+    this.oauth2Client.setCredentials({});
+  }
+  /**
+   * Check if token is expired or will expire soon
+   */
+  isTokenExpired(bufferSeconds = 300) {
+    if (!this.tokens?.expiryDate) {
+      return false;
+    }
+    const now = Date.now();
+    const expiry = this.tokens.expiryDate;
+    return now >= expiry - bufferSeconds * 1e3;
+  }
+  /**
+   * Ensure valid access token (refresh if needed)
+   */
+  async ensureValidToken() {
+    if (this.isTokenExpired()) {
+      await this.refreshAccessToken();
+    }
+  }
+};
+function createGoogleDriveAuth(config, callbacks) {
+  return new GoogleDriveAuth(config, callbacks);
+}
+
+// src/modules/google-drive/index.ts
+var FOLDER_MIME_TYPE = "application/vnd.google-apps.folder";
+var GoogleDriveModule = class extends BaseStorageModule {
+  constructor() {
+    super(...arguments);
+    this.provider = "google_drive";
+    this.auth = null;
+    this.drive = null;
+    this.rootFolderId = "root";
+    this.authCallbacks = {};
+  }
+  /**
+   * Set authentication callbacks for token persistence
+   */
+  setAuthCallbacks(callbacks) {
+    this.authCallbacks = callbacks;
+  }
+  async initialize(config) {
+    await super.initialize(config);
+    const driveConfig = this.getProviderConfig();
+    if (!driveConfig.clientId || !driveConfig.clientSecret) {
+      throw new AuthenticationError("google_drive", "Missing client ID or client secret");
+    }
+    this.auth = createGoogleDriveAuth(
+      {
+        clientId: driveConfig.clientId,
+        clientSecret: driveConfig.clientSecret,
+        redirectUri: driveConfig.redirectUri
+      },
+      this.authCallbacks
+    );
+    if (driveConfig.refreshToken) {
+      await this.auth.setTokens({
+        accessToken: driveConfig.accessToken || "",
+        refreshToken: driveConfig.refreshToken
+      });
+    }
+    this.drive = import_googleapis2.google.drive({ version: "v3", auth: this.auth.getClient() });
+    this.rootFolderId = driveConfig.rootFolderId || "root";
+  }
+  /**
+   * Get the auth instance for OAuth flow
+   */
+  getAuth() {
+    if (!this.auth) {
+      throw new AuthenticationError("google_drive", "Module not initialized");
+    }
+    return this.auth;
+  }
+  /**
+   * Check if user is authenticated
+   */
+  isAuthenticated() {
+    return this.auth?.isAuthenticated() ?? false;
+  }
+  /**
+   * Authenticate with provided tokens
+   */
+  async authenticate(tokens) {
+    if (!this.auth) {
+      throw new AuthenticationError("google_drive", "Module not initialized");
+    }
+    await this.auth.setTokens(tokens);
+  }
+  /**
+   * Ensure authenticated before operations
+   */
+  async ensureAuthenticated() {
+    this.ensureInitialized();
+    if (!this.isAuthenticated()) {
+      throw new AuthenticationError("google_drive", "Not authenticated. Please connect your Google Drive.");
+    }
+    await this.auth.ensureValidToken();
+  }
+  /**
+   * Get folder ID from path (creates folders if needed for certain operations)
+   */
+  async getIdFromPath(virtualPath, createIfMissing = false) {
+    const normalized = this.normalizePath(virtualPath);
+    if (normalized === "/") {
+      return this.rootFolderId;
+    }
+    const segments = normalized.split("/").filter(Boolean);
+    let currentParentId = this.rootFolderId;
+    for (const segment of segments) {
+      const query = `name='${segment}' and '${currentParentId}' in parents and trashed=false`;
+      const response = await this.drive.files.list({
+        q: query,
+        fields: "files(id, name, mimeType)",
+        pageSize: 1
+      });
+      if (response.data.files && response.data.files.length > 0) {
+        currentParentId = response.data.files[0].id;
+      } else if (createIfMissing) {
+        const createResponse = await this.drive.files.create({
+          requestBody: {
+            name: segment,
+            mimeType: FOLDER_MIME_TYPE,
+            parents: [currentParentId]
+          },
+          fields: "id"
+        });
+        currentParentId = createResponse.data.id;
+      } else {
+        return null;
+      }
+    }
+    return currentParentId;
+  }
+  /**
+   * Convert Drive file to FileSystemItem
+   */
+  driveFileToItem(file, virtualPath) {
+    const isFolder2 = file.mimeType === FOLDER_MIME_TYPE;
+    const path3 = virtualPath || "";
+    if (isFolder2) {
+      return createFolderItem({
+        id: file.id,
+        name: file.name,
+        path: path3,
+        createdAt: file.createdTime ? new Date(file.createdTime) : /* @__PURE__ */ new Date(),
+        modifiedAt: file.modifiedTime ? new Date(file.modifiedTime) : /* @__PURE__ */ new Date(),
+        metadata: {
+          driveId: file.id,
+          webViewLink: file.webViewLink
+        }
+      });
+    }
+    return createFileItem({
+      id: file.id,
+      name: file.name,
+      path: path3,
+      size: parseInt(file.size || "0", 10),
+      mimeType: file.mimeType || "application/octet-stream",
+      createdAt: file.createdTime ? new Date(file.createdTime) : /* @__PURE__ */ new Date(),
+      modifiedAt: file.modifiedTime ? new Date(file.modifiedTime) : /* @__PURE__ */ new Date(),
+      metadata: {
+        driveId: file.id,
+        webViewLink: file.webViewLink,
+        thumbnailLink: file.thumbnailLink
+      }
+    });
+  }
+  async createDirectory(virtualPath) {
+    try {
+      await this.ensureAuthenticated();
+      const normalized = this.normalizePath(virtualPath);
+      const parentPath = this.getParentPath(normalized);
+      const folderName = this.getBaseName(normalized);
+      const parentId = await this.getIdFromPath(parentPath, true);
+      if (!parentId) {
+        throw new DirectoryNotFoundError(parentPath);
+      }
+      const existingQuery = `name='${folderName}' and '${parentId}' in parents and mimeType='${FOLDER_MIME_TYPE}' and trashed=false`;
+      const existingResponse = await this.drive.files.list({
+        q: existingQuery,
+        fields: "files(id)",
+        pageSize: 1
+      });
+      if (existingResponse.data.files && existingResponse.data.files.length > 0) {
+        return this.errorResult(`Directory already exists: ${virtualPath}`);
+      }
+      const response = await this.drive.files.create({
+        requestBody: {
+          name: folderName,
+          mimeType: FOLDER_MIME_TYPE,
+          parents: [parentId]
+        },
+        fields: "id, name, mimeType, createdTime, modifiedTime, webViewLink"
+      });
+      const item = this.driveFileToItem(response.data, normalized);
+      return this.successResult(item);
+    } catch (error) {
+      if (error instanceof AuthenticationError || error instanceof DirectoryNotFoundError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to create directory: ${error.message}`);
+    }
+  }
+  async removeDirectory(virtualPath, recursive = false) {
+    try {
+      await this.ensureAuthenticated();
+      const folderId = await this.getIdFromPath(virtualPath);
+      if (!folderId) {
+        throw new DirectoryNotFoundError(virtualPath);
+      }
+      if (!recursive) {
+        const childrenResponse = await this.drive.files.list({
+          q: `'${folderId}' in parents and trashed=false`,
+          fields: "files(id)",
+          pageSize: 1
+        });
+        if (childrenResponse.data.files && childrenResponse.data.files.length > 0) {
+          return this.errorResult(`Directory is not empty: ${virtualPath}`);
+        }
+      }
+      await this.drive.files.delete({ fileId: folderId });
+      return this.successResult();
+    } catch (error) {
+      if (error instanceof DirectoryNotFoundError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to remove directory: ${error.message}`);
+    }
+  }
+  async uploadFile(source, remotePath, options = {}) {
+    try {
+      await this.ensureAuthenticated();
+      const normalized = this.normalizePath(remotePath);
+      const parentPath = this.getParentPath(normalized);
+      const fileName = this.getBaseName(normalized);
+      const parentId = await this.getIdFromPath(parentPath, true);
+      if (!parentId) {
+        throw new DirectoryNotFoundError(parentPath);
+      }
+      if (!options.overwrite) {
+        const existingQuery = `name='${fileName}' and '${parentId}' in parents and trashed=false`;
+        const existingResponse = await this.drive.files.list({
+          q: existingQuery,
+          fields: "files(id)",
+          pageSize: 1
+        });
+        if (existingResponse.data.files && existingResponse.data.files.length > 0) {
+          throw new FileExistsError(remotePath);
+        }
+      }
+      let media;
+      if (typeof source === "string") {
+        const fs3 = await import("fs");
+        media = {
+          mimeType: "application/octet-stream",
+          body: fs3.createReadStream(source)
+        };
+      } else if (Buffer.isBuffer(source)) {
+        media = {
+          mimeType: "application/octet-stream",
+          body: source
+        };
+      } else {
+        media = {
+          mimeType: "application/octet-stream",
+          body: import_stream2.Readable.fromWeb(source)
+        };
+      }
+      const response = await this.drive.files.create({
+        requestBody: {
+          name: fileName,
+          parents: [parentId]
+        },
+        media,
+        fields: "id, name, mimeType, size, createdTime, modifiedTime, webViewLink, thumbnailLink"
+      });
+      if (options.onProgress) {
+        options.onProgress(100, parseInt(response.data.size || "0", 10), parseInt(response.data.size || "0", 10));
+      }
+      const item = this.driveFileToItem(response.data, normalized);
+      return this.successResult(item);
+    } catch (error) {
+      if (error instanceof AuthenticationError || error instanceof DirectoryNotFoundError || error instanceof FileExistsError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to upload file: ${error.message}`);
+    }
+  }
+  async downloadFile(remotePath, localPath, options = {}) {
+    try {
+      await this.ensureAuthenticated();
+      const fileId = await this.getIdFromPath(remotePath);
+      if (!fileId) {
+        throw new FileNotFoundError(remotePath);
+      }
+      const response = await this.drive.files.get(
+        { fileId, alt: "media" },
+        { responseType: "arraybuffer" }
+      );
+      const buffer = Buffer.from(response.data);
+      if (options.onProgress) {
+        options.onProgress(100, buffer.length, buffer.length);
+      }
+      if (localPath) {
+        const fs3 = await import("fs");
+        const path3 = await import("path");
+        await fs3.promises.mkdir(path3.dirname(localPath), { recursive: true });
+        await fs3.promises.writeFile(localPath, buffer);
+        return this.successResult(localPath);
+      }
+      return this.successResult(buffer);
+    } catch (error) {
+      if (error instanceof FileNotFoundError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to download file: ${error.message}`);
+    }
+  }
+  async moveItem(sourcePath, destinationPath, _options = {}) {
+    try {
+      await this.ensureAuthenticated();
+      const fileId = await this.getIdFromPath(sourcePath);
+      if (!fileId) {
+        throw new FileNotFoundError(sourcePath);
+      }
+      const file = await this.drive.files.get({
+        fileId,
+        fields: "parents"
+      });
+      const previousParents = file.data.parents?.join(",") || "";
+      const destParentPath = this.getParentPath(destinationPath);
+      const newName = this.getBaseName(destinationPath);
+      const newParentId = await this.getIdFromPath(destParentPath, true);
+      if (!newParentId) {
+        throw new DirectoryNotFoundError(destParentPath);
+      }
+      const response = await this.drive.files.update({
+        fileId,
+        addParents: newParentId,
+        removeParents: previousParents,
+        requestBody: {
+          name: newName
+        },
+        fields: "id, name, mimeType, size, createdTime, modifiedTime, webViewLink, thumbnailLink"
+      });
+      const item = this.driveFileToItem(response.data, destinationPath);
+      return this.successResult(item);
+    } catch (error) {
+      if (error instanceof FileNotFoundError || error instanceof DirectoryNotFoundError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to move item: ${error.message}`);
+    }
+  }
+  async deleteFile(virtualPath) {
+    try {
+      await this.ensureAuthenticated();
+      const fileId = await this.getIdFromPath(virtualPath);
+      if (!fileId) {
+        throw new FileNotFoundError(virtualPath);
+      }
+      await this.drive.files.delete({ fileId });
+      return this.successResult();
+    } catch (error) {
+      if (error instanceof FileNotFoundError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to delete file: ${error.message}`);
+    }
+  }
+  async renameFile(virtualPath, newName, _options = {}) {
+    try {
+      await this.ensureAuthenticated();
+      const fileId = await this.getIdFromPath(virtualPath);
+      if (!fileId) {
+        throw new FileNotFoundError(virtualPath);
+      }
+      const response = await this.drive.files.update({
+        fileId,
+        requestBody: {
+          name: newName
+        },
+        fields: "id, name, mimeType, size, createdTime, modifiedTime, webViewLink, thumbnailLink"
+      });
+      const parentPath = this.getParentPath(virtualPath);
+      const newPath = this.joinPath(parentPath, newName);
+      const item = this.driveFileToItem(response.data, newPath);
+      return this.successResult(item);
+    } catch (error) {
+      if (error instanceof FileNotFoundError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to rename file: ${error.message}`);
+    }
+  }
+  async renameFolder(virtualPath, newName, _options = {}) {
+    try {
+      await this.ensureAuthenticated();
+      const folderId = await this.getIdFromPath(virtualPath);
+      if (!folderId) {
+        throw new DirectoryNotFoundError(virtualPath);
+      }
+      const response = await this.drive.files.update({
+        fileId: folderId,
+        requestBody: {
+          name: newName
+        },
+        fields: "id, name, mimeType, createdTime, modifiedTime, webViewLink"
+      });
+      const parentPath = this.getParentPath(virtualPath);
+      const newPath = this.joinPath(parentPath, newName);
+      const item = this.driveFileToItem(response.data, newPath);
+      return this.successResult(item);
+    } catch (error) {
+      if (error instanceof DirectoryNotFoundError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to rename folder: ${error.message}`);
+    }
+  }
+  async listDirectory(virtualPath, options = {}) {
+    try {
+      await this.ensureAuthenticated();
+      const folderId = await this.getIdFromPath(virtualPath);
+      if (!folderId) {
+        throw new DirectoryNotFoundError(virtualPath);
+      }
+      const items = [];
+      let pageToken;
+      do {
+        const response = await this.drive.files.list({
+          q: `'${folderId}' in parents and trashed=false`,
+          fields: "nextPageToken, files(id, name, mimeType, size, createdTime, modifiedTime, webViewLink, thumbnailLink)",
+          pageSize: 100,
+          pageToken,
+          orderBy: "folder,name"
+        });
+        if (response.data.files) {
+          for (const file of response.data.files) {
+            if (!options.includeHidden && file.name?.startsWith(".")) {
+              continue;
+            }
+            const itemPath = this.joinPath(virtualPath, file.name);
+            const item = this.driveFileToItem(file, itemPath);
+            if (options.filter && !options.filter(item)) {
+              continue;
+            }
+            items.push(item);
+            if (options.recursive && file.mimeType === FOLDER_MIME_TYPE) {
+              const subResult = await this.listDirectory(itemPath, options);
+              if (subResult.success && subResult.data) {
+                items.push(...subResult.data);
+              }
+            }
+          }
+        }
+        pageToken = response.data.nextPageToken || void 0;
+      } while (pageToken);
+      return this.successResult(items);
+    } catch (error) {
+      if (error instanceof DirectoryNotFoundError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to list directory: ${error.message}`);
+    }
+  }
+  async getItem(virtualPath) {
+    try {
+      await this.ensureAuthenticated();
+      const fileId = await this.getIdFromPath(virtualPath);
+      if (!fileId) {
+        throw new FileNotFoundError(virtualPath);
+      }
+      const response = await this.drive.files.get({
+        fileId,
+        fields: "id, name, mimeType, size, createdTime, modifiedTime, webViewLink, thumbnailLink"
+      });
+      const item = this.driveFileToItem(response.data, virtualPath);
+      return this.successResult(item);
+    } catch (error) {
+      if (error instanceof FileNotFoundError) {
+        return this.errorResult(error.message);
+      }
+      return this.errorResult(`Failed to get item: ${error.message}`);
+    }
+  }
+  async exists(virtualPath) {
+    try {
+      await this.ensureAuthenticated();
+      const fileId = await this.getIdFromPath(virtualPath);
+      return fileId !== null;
+    } catch {
+      return false;
+    }
+  }
+  async getFolderTree(path3 = "/", depth = 3) {
+    try {
+      await this.ensureAuthenticated();
+      return super.getFolderTree(path3, depth);
+    } catch (error) {
+      return this.errorResult(`Failed to get folder tree: ${error.message}`);
+    }
+  }
+};
+function createGoogleDriveModule() {
+  return new GoogleDriveModule();
+}
+
+// src/modules/index.ts
+var moduleRegistry = {
+  local: createLocalModule,
+  google_drive: createGoogleDriveModule
+};
+function getRegisteredProviders() {
+  return Object.keys(moduleRegistry);
+}
+function isProviderRegistered(provider) {
+  return provider in moduleRegistry;
+}
+function createModule(provider) {
+  const factory = moduleRegistry[provider];
+  if (!factory) {
+    throw new ConfigurationError(`Unknown storage provider: ${provider}`);
+  }
+  return factory();
+}
+async function createAndInitializeModule(config) {
+  const module2 = createModule(config.provider);
+  await module2.initialize(config);
+  return module2;
+}
+function registerModule(provider, factory) {
+  moduleRegistry[provider] = factory;
+}
+
+// src/services/file-manager.ts
+var FileManager = class {
+  constructor(options = {}) {
+    this.module = null;
+    this.config = null;
+    this.initialized = false;
+    this.options = {
+      autoInit: true,
+      ...options
+    };
+  }
+  /**
+   * Initialize the file manager with configuration
+   */
+  async initialize(config) {
+    if (this.initialized) {
+      return;
+    }
+    if (config) {
+      this.config = config;
+    } else if (this.options.config) {
+      this.config = this.options.config;
+    } else {
+      this.config = await loadConfigAsync(this.options.configPath);
+    }
+    this.module = await createAndInitializeModule(this.config);
+    this.initialized = true;
+  }
+  /**
+   * Initialize synchronously (uses sync config loading)
+   */
+  initializeSync(config) {
+    if (this.initialized) {
+      return;
+    }
+    if (config) {
+      this.config = config;
+    } else if (this.options.config) {
+      this.config = this.options.config;
+    } else {
+      this.config = loadConfig(this.options.configPath);
+    }
+    this.module = createModule(this.config.provider);
+  }
+  /**
+   * Check if manager is initialized
+   */
+  isInitialized() {
+    return this.initialized;
+  }
+  /**
+   * Get the current configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Get the current provider
+   */
+  getProvider() {
+    return this.config?.provider ?? null;
+  }
+  /**
+   * Get the underlying storage module
+   */
+  getModule() {
+    this.ensureInitialized();
+    return this.module;
+  }
+  /**
+   * Ensure manager is initialized
+   */
+  ensureInitialized() {
+    if (!this.initialized || !this.module) {
+      throw new Error("FileManager not initialized. Call initialize() first.");
+    }
+  }
+  // ============ Directory Operations ============
+  /**
+   * Create a directory at the specified path
+   */
+  async createDirectory(path3) {
+    this.ensureInitialized();
+    return this.module.createDirectory(path3);
+  }
+  /**
+   * Remove a directory
+   * @param path - Directory path
+   * @param recursive - If true, remove directory and all contents
+   */
+  async removeDirectory(path3, recursive = false) {
+    this.ensureInitialized();
+    return this.module.removeDirectory(path3, recursive);
+  }
+  // ============ File Operations ============
+  /**
+   * Upload/save a file
+   * @param source - File path, Buffer, or ReadableStream
+   * @param remotePath - Destination path in storage
+   * @param options - Upload options
+   */
+  async uploadFile(source, remotePath, options) {
+    this.ensureInitialized();
+    return this.module.uploadFile(source, remotePath, options);
+  }
+  /**
+   * Download a file
+   * @param remotePath - Path in storage
+   * @param localPath - Optional local destination path
+   * @param options - Download options
+   */
+  async downloadFile(remotePath, localPath, options) {
+    this.ensureInitialized();
+    return this.module.downloadFile(remotePath, localPath, options);
+  }
+  /**
+   * Move a file or folder
+   * @param sourcePath - Current path
+   * @param destinationPath - New path
+   * @param options - Move options
+   */
+  async moveItem(sourcePath, destinationPath, options) {
+    this.ensureInitialized();
+    return this.module.moveItem(sourcePath, destinationPath, options);
+  }
+  /**
+   * Delete a file
+   */
+  async deleteFile(path3) {
+    this.ensureInitialized();
+    return this.module.deleteFile(path3);
+  }
+  /**
+   * Rename a file
+   * @param path - Current file path
+   * @param newName - New filename (not full path)
+   * @param options - Rename options
+   */
+  async renameFile(path3, newName, options) {
+    this.ensureInitialized();
+    return this.module.renameFile(path3, newName, options);
+  }
+  /**
+   * Rename a folder
+   * @param path - Current folder path
+   * @param newName - New folder name (not full path)
+   * @param options - Rename options
+   */
+  async renameFolder(path3, newName, options) {
+    this.ensureInitialized();
+    return this.module.renameFolder(path3, newName, options);
+  }
+  // ============ Query Operations ============
+  /**
+   * List contents of a directory
+   * @param path - Directory path
+   * @param options - List options
+   */
+  async listDirectory(path3, options) {
+    this.ensureInitialized();
+    return this.module.listDirectory(path3, options);
+  }
+  /**
+   * Get information about a file or folder
+   */
+  async getItem(path3) {
+    this.ensureInitialized();
+    return this.module.getItem(path3);
+  }
+  /**
+   * Check if a file or folder exists
+   */
+  async exists(path3) {
+    this.ensureInitialized();
+    return this.module.exists(path3);
+  }
+  /**
+   * Get folder tree structure
+   * @param path - Starting path (default: root)
+   * @param depth - Maximum depth to traverse
+   */
+  async getFolderTree(path3 = "/", depth = 3) {
+    this.ensureInitialized();
+    return this.module.getFolderTree(path3, depth);
+  }
+  // ============ Convenience Methods ============
+  /**
+   * Create a file with string content
+   */
+  async writeFile(path3, content, options) {
+    const buffer = Buffer.from(content, "utf-8");
+    return this.uploadFile(buffer, path3, options);
+  }
+  /**
+   * Read a file as string
+   */
+  async readFile(path3) {
+    const result = await this.downloadFile(path3);
+    if (!result.success) {
+      return { success: false, error: result.error };
+    }
+    if (Buffer.isBuffer(result.data)) {
+      return { success: true, data: result.data.toString("utf-8") };
+    }
+    const fs3 = await import("fs");
+    const content = await fs3.promises.readFile(result.data, "utf-8");
+    return { success: true, data: content };
+  }
+  /**
+   * Copy a file to a new location
+   */
+  async copyFile(sourcePath, destinationPath, options) {
+    const downloadResult = await this.downloadFile(sourcePath);
+    if (!downloadResult.success) {
+      return { success: false, error: downloadResult.error };
+    }
+    const buffer = Buffer.isBuffer(downloadResult.data) ? downloadResult.data : await import("fs").then((fs3) => fs3.promises.readFile(downloadResult.data));
+    return this.uploadFile(buffer, destinationPath, options);
+  }
+  /**
+   * Ensure a directory exists (creates if needed)
+   */
+  async ensureDirectory(path3) {
+    const exists = await this.exists(path3);
+    if (exists) {
+      const item = await this.getItem(path3);
+      if (item.success && item.data?.isDirectory) {
+        return { success: true, data: item.data };
+      }
+      return { success: false, error: "Path exists but is not a directory" };
+    }
+    return this.createDirectory(path3);
+  }
+};
+function createFileManager(options) {
+  return new FileManager(options);
+}
+async function createInitializedFileManager(options) {
+  const manager = new FileManager(options);
+  await manager.initialize();
+  return manager;
+}
+
+// src/common/naming-utils.ts
+var DEFAULT_DATE_FORMATS = [
+  "YYYY",
+  "YY",
+  "MM",
+  "M",
+  "DD",
+  "D",
+  "MMM",
+  "MMMM",
+  "YYYY-MM-DD",
+  "YYYY-MMM-DD",
+  "DD-MM-YYYY",
+  "MM-DD-YYYY"
+];
+var MONTH_NAMES_SHORT = [
+  "Jan",
+  "Feb",
+  "Mar",
+  "Apr",
+  "May",
+  "Jun",
+  "Jul",
+  "Aug",
+  "Sep",
+  "Oct",
+  "Nov",
+  "Dec"
+];
+var MONTH_NAMES_FULL = [
+  "January",
+  "February",
+  "March",
+  "April",
+  "May",
+  "June",
+  "July",
+  "August",
+  "September",
+  "October",
+  "November",
+  "December"
+];
+var SYSTEM_DATE_VARIABLES = [
+  { variable_name: "YYYY", description: "Full year (4 digits)", example_value: "2024", category: "date" },
+  { variable_name: "YY", description: "Year (2 digits)", example_value: "24", category: "date" },
+  { variable_name: "MM", description: "Month (2 digits, 01-12)", example_value: "01", category: "date" },
+  { variable_name: "M", description: "Month (1-12)", example_value: "1", category: "date" },
+  { variable_name: "DD", description: "Day (2 digits, 01-31)", example_value: "15", category: "date" },
+  { variable_name: "D", description: "Day (1-31)", example_value: "15", category: "date" },
+  { variable_name: "MMM", description: "Short month name", example_value: "Jan", category: "date" },
+  { variable_name: "MMMM", description: "Full month name", example_value: "January", category: "date" },
+  { variable_name: "YYYY-MM-DD", description: "ISO date format", example_value: "2024-01-15", category: "date" },
+  { variable_name: "YYYY-MMM-DD", description: "Date with month name", example_value: "2024-Jan-15", category: "date" },
+  { variable_name: "DD-MM-YYYY", description: "Day-Month-Year", example_value: "15-01-2024", category: "date" },
+  { variable_name: "MM-DD-YYYY", description: "Month-Day-Year", example_value: "01-15-2024", category: "date" }
+];
+var SYSTEM_FILE_VARIABLES = [
+  { variable_name: "original_name", description: "Original filename without extension", example_value: "document", category: "file" },
+  { variable_name: "extension", description: "Original file extension with dot", example_value: ".pdf", category: "file" },
+  { variable_name: "ext", description: "Extension without dot", example_value: "pdf", category: "file" }
+];
+var SYSTEM_COUNTER_VARIABLES = [
+  { variable_name: "counter", description: "Auto-incrementing number (3 digits)", example_value: "001", category: "counter" }
+];
+var ALL_SYSTEM_VARIABLES = [
+  ...SYSTEM_DATE_VARIABLES,
+  ...SYSTEM_FILE_VARIABLES,
+  ...SYSTEM_COUNTER_VARIABLES
+];
+function formatDateToken(date, format) {
+  const year = date.getFullYear();
+  const month = date.getMonth();
+  const day = date.getDate();
+  switch (format) {
+    case "YYYY":
+      return String(year);
+    case "YY":
+      return String(year).slice(-2);
+    case "MM":
+      return String(month + 1).padStart(2, "0");
+    case "M":
+      return String(month + 1);
+    case "DD":
+      return String(day).padStart(2, "0");
+    case "D":
+      return String(day);
+    case "MMM":
+      return MONTH_NAMES_SHORT[month];
+    case "MMMM":
+      return MONTH_NAMES_FULL[month];
+    case "YYYY-MM-DD":
+      return `${year}-${String(month + 1).padStart(2, "0")}-${String(day).padStart(2, "0")}`;
+    case "YYYY-MMM-DD":
+      return `${year}-${MONTH_NAMES_SHORT[month]}-${String(day).padStart(2, "0")}`;
+    case "DD-MM-YYYY":
+      return `${String(day).padStart(2, "0")}-${String(month + 1).padStart(2, "0")}-${year}`;
+    case "MM-DD-YYYY":
+      return `${String(month + 1).padStart(2, "0")}-${String(day).padStart(2, "0")}-${year}`;
+    default:
+      return format;
+  }
+}
+function isDateVariable(variableName, dateFormats = DEFAULT_DATE_FORMATS) {
+  return dateFormats.includes(variableName);
+}
+function isFileMetadataVariable(variableName) {
+  return ["original_name", "extension", "ext"].includes(variableName);
+}
+function isCounterVariable(variableName) {
+  return variableName === "counter" || variableName.startsWith("counter:");
+}
+function formatCounter(value, digits = 3) {
+  return String(value).padStart(digits, "0");
+}
+function getFileMetadataValues(filename) {
+  if (!filename) {
+    return {
+      original_name: "",
+      extension: "",
+      ext: ""
+    };
+  }
+  const extension = getExtension(filename);
+  const originalName = getNameWithoutExtension(filename);
+  return {
+    original_name: originalName,
+    extension,
+    ext: extension.startsWith(".") ? extension.slice(1) : extension
+  };
+}
+function generateNameFromPattern(pattern, variables, options = {}, originalFileName) {
+  if (pattern.length === 0) {
+    return { success: false, error: "Pattern is empty" };
+  }
+  const {
+    dateFormats = DEFAULT_DATE_FORMATS,
+    date = /* @__PURE__ */ new Date(),
+    counterValue = 1,
+    counterDigits = 3
+  } = options;
+  const fileMetadata = getFileMetadataValues(originalFileName);
+  const parts = [];
+  for (const segment of pattern) {
+    if (segment.type === "literal") {
+      parts.push(segment.value);
+    } else if (segment.type === "variable") {
+      const varName = segment.value;
+      if (isDateVariable(varName, dateFormats)) {
+        parts.push(formatDateToken(date, varName));
+      } else if (isFileMetadataVariable(varName)) {
+        parts.push(fileMetadata[varName] || "");
+      } else if (isCounterVariable(varName)) {
+        if (varName.startsWith("counter:")) {
+          const customDigits = parseInt(varName.split(":")[1], 10);
+          parts.push(formatCounter(counterValue, isNaN(customDigits) ? counterDigits : customDigits));
+        } else {
+          parts.push(formatCounter(counterValue, counterDigits));
+        }
+      } else if (varName in variables) {
+        parts.push(variables[varName]);
+      } else {
+        return {
+          success: false,
+          error: `Missing value for variable: ${varName}`
+        };
+      }
+    }
+  }
+  const name = parts.join("");
+  if (!name.trim()) {
+    return { success: false, error: "Generated name is empty" };
+  }
+  return { success: true, name };
+}
+function hazo_files_generate_folder_name(schema, variables, options) {
+  const result = generateNameFromPattern(
+    schema.folderPattern,
+    variables,
+    options
+  );
+  if (!result.success || !result.name) {
+    return result;
+  }
+  const segments = result.name.split("/");
+  const sanitizedSegments = segments.map((seg) => seg.trim()).filter((seg) => seg.length > 0).map((seg) => sanitizeFilename(seg));
+  if (sanitizedSegments.length === 0) {
+    return { success: false, error: "Generated folder name is empty" };
+  }
+  return {
+    success: true,
+    name: sanitizedSegments.join("/")
+  };
+}
+function hazo_files_generate_file_name(schema, variables, originalFileName, options) {
+  const { preserveExtension = true, ...restOptions } = options || {};
+  const result = generateNameFromPattern(
+    schema.filePattern,
+    variables,
+    restOptions,
+    originalFileName
+  );
+  if (!result.success || !result.name) {
+    return result;
+  }
+  let finalName = result.name;
+  if (originalFileName && preserveExtension) {
+    const originalExtension = getExtension(originalFileName);
+    if (originalExtension) {
+      const nameWithoutExt = getNameWithoutExtension(finalName);
+      finalName = nameWithoutExt + originalExtension;
+    }
+  }
+  return {
+    success: true,
+    name: sanitizeFilename(finalName)
+  };
+}
+function validateNamingRuleSchema(schema) {
+  if (!schema || typeof schema !== "object") return false;
+  const s = schema;
+  if (typeof s.version !== "number") return false;
+  if (!Array.isArray(s.filePattern) || !Array.isArray(s.folderPattern)) return false;
+  const isValidSegment = (seg) => {
+    if (!seg || typeof seg !== "object") return false;
+    const segment = seg;
+    return typeof segment.id === "string" && (segment.type === "variable" || segment.type === "literal") && typeof segment.value === "string";
+  };
+  return s.filePattern.every(isValidSegment) && s.folderPattern.every(isValidSegment);
+}
+function createEmptyNamingRuleSchema() {
+  return {
+    version: 1,
+    filePattern: [],
+    folderPattern: [],
+    metadata: {
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    }
+  };
+}
+function generateSegmentId() {
+  return `seg_${Date.now()}_${Math.random().toString(36).substring(2, 11)}`;
+}
+function createVariableSegment(variableName) {
+  return {
+    id: generateSegmentId(),
+    type: "variable",
+    value: variableName
+  };
+}
+function createLiteralSegment(text) {
+  return {
+    id: generateSegmentId(),
+    type: "literal",
+    value: text
+  };
+}
+function patternToString(pattern) {
+  return pattern.map((seg) => seg.type === "variable" ? `{${seg.value}}` : seg.value).join("");
+}
+function parsePatternString(patternStr) {
+  const segments = [];
+  const regex = /\{([^}]+)\}|([^{]+)/g;
+  let match;
+  while ((match = regex.exec(patternStr)) !== null) {
+    if (match[1]) {
+      segments.push(createVariableSegment(match[1]));
+    } else if (match[2]) {
+      segments.push(createLiteralSegment(match[2]));
+    }
+  }
+  return segments;
+}
+function clonePattern(pattern) {
+  return pattern.map((seg) => ({
+    ...seg,
+    id: generateSegmentId()
+  }));
+}
+function getSystemVariablePreviewValues(date = /* @__PURE__ */ new Date(), options = {}) {
+  const { counterValue = 1, counterDigits = 3, originalFileName } = options;
+  const fileMetadata = getFileMetadataValues(originalFileName);
+  const values = {};
+  for (const format of DEFAULT_DATE_FORMATS) {
+    values[format] = formatDateToken(date, format);
+  }
+  values.original_name = fileMetadata.original_name || "document";
+  values.extension = fileMetadata.extension || ".pdf";
+  values.ext = fileMetadata.ext || "pdf";
+  values.counter = formatCounter(counterValue, counterDigits);
+  return values;
+}
+function generatePreviewName(pattern, userVariables, options = {}) {
+  if (pattern.length === 0) {
+    return "(empty pattern)";
+  }
+  const systemValues = getSystemVariablePreviewValues(
+    options.date,
+    options
+  );
+  const userValues = {};
+  for (const variable of userVariables) {
+    userValues[variable.variable_name] = variable.example_value;
+  }
+  const allValues = { ...userValues, ...systemValues };
+  const parts = [];
+  for (const segment of pattern) {
+    if (segment.type === "literal") {
+      parts.push(segment.value);
+    } else if (segment.type === "variable") {
+      const value = allValues[segment.value];
+      if (value !== void 0) {
+        parts.push(value);
+      } else {
+        parts.push(`{${segment.value}}`);
+      }
+    }
+  }
+  return parts.join("") || "(empty)";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ALL_SYSTEM_VARIABLES,
+  AuthenticationError,
+  ConfigurationError,
+  DEFAULT_DATE_FORMATS,
+  DirectoryExistsError,
+  DirectoryNotEmptyError,
+  DirectoryNotFoundError,
+  FileExistsError,
+  FileManager,
+  FileNotFoundError,
+  FileTooLargeError,
+  GoogleDriveAuth,
+  GoogleDriveModule,
+  HazoFilesError,
+  InvalidExtensionError,
+  InvalidPathError,
+  LocalStorageModule,
+  OperationError,
+  PermissionDeniedError,
+  SYSTEM_COUNTER_VARIABLES,
+  SYSTEM_DATE_VARIABLES,
+  SYSTEM_FILE_VARIABLES,
+  clonePattern,
+  createAndInitializeModule,
+  createEmptyNamingRuleSchema,
+  createFileItem,
+  createFileManager,
+  createFolderItem,
+  createGoogleDriveAuth,
+  createGoogleDriveModule,
+  createInitializedFileManager,
+  createLiteralSegment,
+  createLocalModule,
+  createModule,
+  createVariableSegment,
+  errorResult,
+  filterItems,
+  formatBytes,
+  formatCounter,
+  formatDateToken,
+  generateId,
+  generatePreviewName,
+  generateSampleConfig,
+  generateSegmentId,
+  getBaseName,
+  getBreadcrumbs,
+  getDirName,
+  getExtension,
+  getExtensionFromMime,
+  getFileCategory,
+  getFileMetadataValues,
+  getMimeType,
+  getNameWithoutExtension,
+  getParentPath,
+  getPathSegments,
+  getRegisteredProviders,
+  getRelativePath,
+  getSystemVariablePreviewValues,
+  hasExtension,
+  hazo_files_generate_file_name,
+  hazo_files_generate_folder_name,
+  isAudio,
+  isChildPath,
+  isCounterVariable,
+  isDateVariable,
+  isDocument,
+  isFile,
+  isFileMetadataVariable,
+  isFolder,
+  isImage,
+  isPreviewable,
+  isProviderRegistered,
+  isText,
+  isVideo,
+  joinPath,
+  loadConfig,
+  loadConfigAsync,
+  normalizePath,
+  parseConfig,
+  parsePatternString,
+  patternToString,
+  registerModule,
+  sanitizeFilename,
+  saveConfig,
+  sortItems,
+  successResult,
+  validateNamingRuleSchema,
+  validatePath
+});
+//# sourceMappingURL=index.js.map