@withwiz/toolkit 0.1.0

package/dist/chunk-JS5VI3OW.js

@@ -0,0 +1,143 @@
+import {
+  AppError
+} from "./chunk-MLGO3HLS.js";
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/error/logging/error-logger.ts
+var LOG_LEVEL_PRIORITY = {
+  ["debug" /* DEBUG */]: 0,
+  ["info" /* INFO */]: 1,
+  ["warn" /* WARN */]: 2,
+  ["error" /* ERROR */]: 3,
+  ["critical" /* CRITICAL */]: 4
+};
+var ErrorLogger = class {
+  constructor(options = {}) {
+    this.options = {
+      minLevel: options.minLevel || "info" /* INFO */,
+      environment: options.environment || process.env.NODE_ENV || "development",
+      version: options.version || process.env.APP_VERSION || "1.0.0",
+      transports: options.transports || []
+    };
+    this.transports = this.options.transports.filter((t) => t.isEnabled());
+  }
+  /**
+   * Transport 추가
+   */
+  addTransport(transport) {
+    if (transport.isEnabled()) {
+      this.transports.push(transport);
+    }
+  }
+  /**
+   * Transport 제거
+   */
+  removeTransport(transportName) {
+    this.transports = this.transports.filter((t) => t.name !== transportName);
+  }
+  /**
+   * Debug 로그
+   */
+  debug(message, context) {
+    this.log("debug" /* DEBUG */, message, context);
+  }
+  /**
+   * Info 로그
+   */
+  info(message, context) {
+    this.log("info" /* INFO */, message, context);
+  }
+  /**
+   * Warning 로그
+   */
+  warn(message, context) {
+    this.log("warn" /* WARN */, message, context);
+  }
+  /**
+   * Error 로그
+   */
+  error(message, context, error) {
+    this.log("error" /* ERROR */, message, context, error);
+  }
+  /**
+   * Critical 로그
+   */
+  critical(message, context, error) {
+    this.log("critical" /* CRITICAL */, message, context, error);
+  }
+  /**
+   * 로그 기록
+   */
+  log(level, message, context, error) {
+    if (!this.shouldLog(level)) {
+      return;
+    }
+    const entry = {
+      level,
+      message,
+      context: this.enrichContext(context, error),
+      error,
+      timestamp: /* @__PURE__ */ new Date()
+    };
+    this.sendToTransports(entry);
+  }
+  /**
+   * 로그 레벨 체크
+   */
+  shouldLog(level) {
+    return LOG_LEVEL_PRIORITY[level] >= LOG_LEVEL_PRIORITY[this.options.minLevel];
+  }
+  /**
+   * 컨텍스트 보강
+   */
+  enrichContext(context, error) {
+    const enriched = __spreadProps(__spreadValues({}, context), {
+      environment: this.options.environment,
+      version: this.options.version,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    if (error) {
+      if (error instanceof AppError) {
+        enriched.errorCode = error.code;
+        enriched.errorMessage = error.message;
+        enriched.errorStack = error.stack;
+      } else if (error instanceof Error) {
+        enriched.errorMessage = error.message;
+        enriched.errorStack = error.stack;
+      }
+    }
+    return enriched;
+  }
+  /**
+   * Transport로 전송
+   */
+  async sendToTransports(entry) {
+    const promises = this.transports.map(
+      (transport) => transport.log(entry).catch((err) => {
+        console.error(`[ErrorLogger] Transport ${transport.name} failed:`, err);
+      })
+    );
+    Promise.all(promises).catch(() => {
+    });
+  }
+  /**
+   * AppError 로깅 헬퍼
+   */
+  logAppError(error, context) {
+    const httpStatus = Math.floor(error.code / 100);
+    if (httpStatus >= 500) {
+      this.error(error.message, __spreadProps(__spreadValues({}, context), { error }));
+    } else if (httpStatus >= 400) {
+      this.warn(error.message, __spreadProps(__spreadValues({}, context), { error }));
+    } else {
+      this.info(error.message, __spreadProps(__spreadValues({}, context), { error }));
+    }
+  }
+};
+
+export {
+  ErrorLogger
+};

package/dist/chunk-KAWVMIRJ.js

@@ -0,0 +1,44 @@
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+
+// src/middleware/response-logger.ts
+var responseLoggerMiddleware = async (context, next) => {
+  const startTime = context.startTime || Date.now();
+  try {
+    const response = await next();
+    const duration = Date.now() - startTime;
+    const path = new URL(context.request.url).pathname;
+    const rl = context.metadata.rateLimit;
+    const rlInfo = rl ? ` rl:${rl.remaining}/${rl.limit}` : "";
+    const userInfo = context.user ? ` u:${context.user.id.slice(0, 8)}` : "";
+    logger.info(`API ${response.status} ${context.request.method} ${path} (${duration}ms)${userInfo}${rlInfo}`);
+    if (context.metadata.rateLimit) {
+      const { limit, remaining, reset } = context.metadata.rateLimit;
+      response.headers.set("X-RateLimit-Limit", String(limit));
+      response.headers.set("X-RateLimit-Remaining", String(remaining));
+      response.headers.set("X-RateLimit-Reset", String(reset));
+    }
+    response.headers.set("X-Request-ID", context.requestId);
+    return response;
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    logger.error("API Error", {
+      requestId: context.requestId,
+      method: context.request.method,
+      path: new URL(context.request.url).pathname,
+      duration: `${duration}ms`,
+      error: error instanceof Error ? error.message : "Unknown error",
+      locale: context.locale,
+      user: context.user ? {
+        id: context.user.id,
+        role: context.user.role
+      } : void 0
+    });
+    throw error;
+  }
+};
+
+export {
+  responseLoggerMiddleware
+};

package/dist/chunk-KMCJIL57.js

@@ -0,0 +1,214 @@
+import {
+  __spreadValues
+} from "./chunk-ORMEWXMH.js";
+
+// src/validators/password-validator.ts
+import { z } from "zod";
+var PasswordStrength = /* @__PURE__ */ ((PasswordStrength2) => {
+  PasswordStrength2["VERY_WEAK"] = "very_weak";
+  PasswordStrength2["WEAK"] = "weak";
+  PasswordStrength2["MEDIUM"] = "medium";
+  PasswordStrength2["STRONG"] = "strong";
+  PasswordStrength2["VERY_STRONG"] = "very_strong";
+  return PasswordStrength2;
+})(PasswordStrength || {});
+var PasswordValidator = class {
+  /**
+   * 비밀번호 유효성 검사
+   */
+  static validate(password, options = {}) {
+    const opts = __spreadValues(__spreadValues({}, this.DEFAULT_OPTIONS), options);
+    const errors = [];
+    if (password.length < opts.minLength) {
+      errors.push(`Password must be at least ${opts.minLength} characters long`);
+    }
+    if (password.length > opts.maxLength) {
+      errors.push(`Password cannot exceed ${opts.maxLength} characters`);
+    }
+    if (opts.requireNumber && !/\d/.test(password)) {
+      errors.push("Password must contain at least one number");
+    }
+    if (opts.requireUppercase && !/[A-Z]/.test(password)) {
+      errors.push("Password must contain at least one uppercase letter");
+    }
+    if (opts.requireLowercase && !/[a-z]/.test(password)) {
+      errors.push("Password must contain at least one lowercase letter");
+    }
+    if (opts.requireSpecialChar && !this.SPECIAL_CHARS.test(password)) {
+      errors.push("Password must contain at least one special character");
+    }
+    if (opts.customPattern && !opts.customPattern.test(password)) {
+      errors.push(opts.customMessage);
+    }
+    const strength = this.calculateStrength(password);
+    const score = this.calculateScore(password);
+    return {
+      isValid: errors.length === 0,
+      errors,
+      strength,
+      score
+    };
+  }
+  /**
+   * 비밀번호 강도 계산
+   */
+  static calculateStrength(password) {
+    const score = this.calculateScore(password);
+    if (score < 20) return "very_weak" /* VERY_WEAK */;
+    if (score < 40) return "weak" /* WEAK */;
+    if (score < 60) return "medium" /* MEDIUM */;
+    if (score < 80) return "strong" /* STRONG */;
+    return "very_strong" /* VERY_STRONG */;
+  }
+  /**
+   * 비밀번호 점수 계산 (0-100)
+   */
+  static calculateScore(password) {
+    let score = 0;
+    if (password.length >= 8) score += 10;
+    if (password.length >= 12) score += 10;
+    if (password.length >= 16) score += 5;
+    if (/[a-z]/.test(password)) score += 10;
+    if (/[A-Z]/.test(password)) score += 10;
+    if (/\d/.test(password)) score += 10;
+    if (this.SPECIAL_CHARS.test(password)) score += 10;
+    const uniqueChars = new Set(password).size;
+    if (uniqueChars >= password.length * 0.7) score += 15;
+    if (password.length >= 12 && uniqueChars >= 8) score += 10;
+    return Math.min(score, 100);
+  }
+  /**
+   * 비밀번호 강도 메시지 반환
+   */
+  static getStrengthMessage(strength) {
+    switch (strength) {
+      case "very_weak" /* VERY_WEAK */:
+        return "Very Weak";
+      case "weak" /* WEAK */:
+        return "Weak";
+      case "medium" /* MEDIUM */:
+        return "Medium";
+      case "strong" /* STRONG */:
+        return "Strong";
+      case "very_strong" /* VERY_STRONG */:
+        return "Very Strong";
+      default:
+        return "Unknown";
+    }
+  }
+  /**
+   * 비밀번호 강도 색상 반환
+   */
+  static getStrengthColor(strength) {
+    switch (strength) {
+      case "very_weak" /* VERY_WEAK */:
+        return "text-red-600";
+      case "weak" /* WEAK */:
+        return "text-orange-600";
+      case "medium" /* MEDIUM */:
+        return "text-yellow-600";
+      case "strong" /* STRONG */:
+        return "text-blue-600";
+      case "very_strong" /* VERY_STRONG */:
+        return "text-green-600";
+      default:
+        return "text-gray-600";
+    }
+  }
+  /**
+   * Zod 스키마 생성
+   */
+  static createZodSchema(options = {}) {
+    const opts = __spreadValues(__spreadValues({}, this.DEFAULT_OPTIONS), options);
+    let schema = z.string().min(opts.minLength, `Password must be at least ${opts.minLength} characters long`).max(opts.maxLength, `Password cannot exceed ${opts.maxLength} characters`);
+    if (opts.requireNumber) {
+      schema = schema.regex(/\d/, "Password must contain at least one number");
+    }
+    if (opts.requireUppercase) {
+      schema = schema.regex(/[A-Z]/, "Password must contain at least one uppercase letter");
+    }
+    if (opts.requireLowercase) {
+      schema = schema.regex(/[a-z]/, "Password must contain at least one lowercase letter");
+    }
+    if (opts.requireSpecialChar) {
+      schema = schema.regex(this.SPECIAL_CHARS, "Password must contain at least one special character");
+    }
+    if (opts.customPattern) {
+      schema = schema.regex(opts.customPattern, opts.customMessage);
+    }
+    return schema;
+  }
+  /**
+   * 비밀번호 확인 검증
+   */
+  static validateConfirmation(password, confirmPassword) {
+    const errors = [];
+    if (password !== confirmPassword) {
+      errors.push("Passwords do not match");
+    }
+    return {
+      isValid: errors.length === 0,
+      errors,
+      strength: "weak" /* WEAK */,
+      score: 0
+    };
+  }
+  /**
+   * 비밀번호 힌트 생성
+   */
+  static generateHint(password) {
+    const hints = [];
+    if (password.length < 8) {
+      hints.push("Enter at least 8 characters");
+    }
+    if (!/\d/.test(password)) {
+      hints.push("Include numbers");
+    }
+    if (!/[A-Z]/.test(password)) {
+      hints.push("Include uppercase letters");
+    }
+    if (!/[a-z]/.test(password)) {
+      hints.push("Include lowercase letters");
+    }
+    if (!this.SPECIAL_CHARS.test(password)) {
+      hints.push("Include special characters");
+    }
+    return hints;
+  }
+};
+// 기본 설정
+PasswordValidator.DEFAULT_OPTIONS = {
+  minLength: 8,
+  maxLength: 128,
+  requireNumber: true,
+  requireUppercase: false,
+  requireLowercase: false,
+  requireSpecialChar: false,
+  customPattern: /^(?=.*\d)/,
+  customMessage: "Password must contain at least one number"
+};
+// 특수문자 패턴
+PasswordValidator.SPECIAL_CHARS = /[!@#$%^&*()_+\-=\[\]{};':"\\|,.<>\/?~`]/;
+var defaultPasswordSchema = PasswordValidator.createZodSchema({
+  minLength: 8,
+  maxLength: 128,
+  requireNumber: true,
+  requireUppercase: false,
+  requireLowercase: false,
+  requireSpecialChar: false
+});
+var strongPasswordSchema = PasswordValidator.createZodSchema({
+  minLength: 12,
+  maxLength: 128,
+  requireNumber: true,
+  requireUppercase: true,
+  requireLowercase: true,
+  requireSpecialChar: true
+});
+
+export {
+  PasswordStrength,
+  PasswordValidator,
+  defaultPasswordSchema,
+  strongPasswordSchema
+};

package/dist/chunk-KWTBD4CM.js

@@ -0,0 +1,145 @@
+import {
+  logger
+} from "./chunk-EZR55KV2.js";
+
+// src/system/utils.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import os from "os";
+var execAsync = promisify(exec);
+function getPlatform() {
+  return os.platform();
+}
+async function runCommand(command) {
+  try {
+    const { stdout } = await execAsync(command);
+    return stdout;
+  } catch (error) {
+    logger.error(`Linux command execution failed: ${command}`, error);
+    throw error;
+  }
+}
+async function runMacCommand(command) {
+  try {
+    const { stdout } = await execAsync(command);
+    return stdout;
+  } catch (error) {
+    logger.error(`macOS command execution failed: ${command}`, error);
+    throw error;
+  }
+}
+async function runPlatformCommand(command) {
+  const platform = getPlatform();
+  if (platform === "darwin") {
+    return runMacCommand(command);
+  } else {
+    return runCommand(command);
+  }
+}
+function formatBytesPerSec(bytesPerSec) {
+  if (bytesPerSec <= 0) return "0 B/s";
+  const k = 1024;
+  const sizes = ["B/s", "KB/s", "MB/s", "GB/s"];
+  const i = Math.floor(Math.log(bytesPerSec) / Math.log(k));
+  return parseFloat((bytesPerSec / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+function convertToBytes(value, unit) {
+  switch (unit) {
+    case "B":
+      return value;
+    case "KiB":
+      return value * 1024;
+    case "MiB":
+      return value * 1024 * 1024;
+    case "GiB":
+      return value * 1024 * 1024 * 1024;
+    default:
+      return value;
+  }
+}
+async function runCommandWithTimeout(command, timeoutMs = 1e4) {
+  try {
+    const { stdout } = await Promise.race([
+      execAsync(command),
+      new Promise(
+        (_, reject) => setTimeout(() => reject(new Error("Command timeout")), timeoutMs)
+      )
+    ]);
+    return stdout;
+  } catch (error) {
+    logger.error(`Command execution failed with timeout: ${command}`, error);
+    throw error;
+  }
+}
+async function runSafeCommand(command, fallbackCommand) {
+  try {
+    const platform = getPlatform();
+    if (platform === "darwin") {
+      return await runMacCommand(command);
+    } else {
+      return await runCommand(command);
+    }
+  } catch (error) {
+    if (fallbackCommand) {
+      try {
+        logger.debug(`Primary command failed, trying fallback: ${fallbackCommand}`);
+        const fallbackPlatform = getPlatform();
+        if (fallbackPlatform === "darwin") {
+          return await runMacCommand(fallbackCommand);
+        } else {
+          return await runCommand(fallbackCommand);
+        }
+      } catch (fallbackError) {
+        logger.error(`Both primary and fallback commands failed:`, { primary: command, fallback: fallbackCommand, error: fallbackError });
+        throw fallbackError;
+      }
+    }
+    throw error;
+  }
+}
+async function commandExists(command) {
+  try {
+    const platform = getPlatform();
+    let checkCommand;
+    if (platform === "darwin") {
+      checkCommand = `which ${command}`;
+    } else {
+      checkCommand = `command -v ${command}`;
+    }
+    await execAsync(checkCommand);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function getRecommendedCommands() {
+  const currentPlatform = getPlatform();
+  if (currentPlatform === "darwin") {
+    return {
+      cpu: ["top", "iostat", "vm_stat"],
+      memory: ["vm_stat", "top", "system_profiler"],
+      disk: ["df", "diskutil"],
+      network: ["nettop", "ifconfig", "netstat"]
+    };
+  } else {
+    return {
+      cpu: ["cat /proc/stat", "top", "uptime"],
+      memory: ["cat /proc/meminfo", "free", "vmstat"],
+      disk: ["df", "lsblk", "cat /proc/mounts"],
+      network: ["cat /proc/net/dev", "netstat", "ss"]
+    };
+  }
+}
+
+export {
+  getPlatform,
+  runCommand,
+  runMacCommand,
+  runPlatformCommand,
+  formatBytesPerSec,
+  convertToBytes,
+  runCommandWithTimeout,
+  runSafeCommand,
+  commandExists,
+  getRecommendedCommands
+};