@withwiz/toolkit 0.1.0

package/dist/middleware/wrappers.js

@@ -0,0 +1,32 @@
+import {
+  withAdminApi,
+  withAuthApi,
+  withCustomApi,
+  withOptionalAuthApi,
+  withPublicApi
+} from "../chunk-SLG26KHZ.js";
+import "../chunk-4ODT3Q4A.js";
+import "../chunk-H5I5GWAA.js";
+import "../chunk-KAWVMIRJ.js";
+import "../chunk-WSQMXMTL.js";
+import "../chunk-UXQRU3EM.js";
+import "../chunk-FOKAATUQ.js";
+import "../chunk-TMVS4F7E.js";
+import "../chunk-62Q7DN5G.js";
+import "../chunk-XHZ5L4FO.js";
+import "../chunk-EEUBKZV4.js";
+import "../chunk-N4YGR5WH.js";
+import "../chunk-KXAWBFJN.js";
+import "../chunk-MLGO3HLS.js";
+import "../chunk-Y3OTJH2S.js";
+import "../chunk-T3LJYAMO.js";
+import "../chunk-AIH3F7JV.js";
+import "../chunk-EZR55KV2.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  withAdminApi,
+  withAuthApi,
+  withCustomApi,
+  withOptionalAuthApi,
+  withPublicApi
+};

package/dist/storage/r2-storage.d.ts

@@ -0,0 +1,38 @@
+/**
+ * CloudFlare R2 Storage Service
+ *
+ * S3 호환 API를 사용하는 CloudFlare R2 오브젝트 스토리지 클라이언트.
+ * 다중 인스턴스 환경에서 파일 공유를 위해 로컬 파일시스템 대신 사용.
+ */
+export interface R2Config {
+    accountId: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    bucketName: string;
+    publicUrl?: string;
+}
+interface UploadResult {
+    key: string;
+    url: string;
+    size: number;
+}
+/**
+ * R2가 활성화되어 있는지 확인
+ */
+export declare function isR2Enabled(): boolean;
+/**
+ * R2에 파일 업로드
+ */
+export declare function uploadToR2(key: string, body: Buffer, contentType: string): Promise<UploadResult>;
+/**
+ * R2에서 파일 삭제
+ */
+export declare function deleteFromR2(key: string): Promise<void>;
+/**
+ * R2에서 파일 조회
+ */
+export declare function getFromR2(key: string): Promise<{
+    body: ReadableStream;
+    contentType: string;
+} | null>;
+export {};

package/dist/storage/r2-storage.js

@@ -0,0 +1,105 @@
+import "../chunk-ORMEWXMH.js";
+
+// src/storage/r2-storage.ts
+import { S3Client, PutObjectCommand, DeleteObjectCommand, GetObjectCommand } from "@aws-sdk/client-s3";
+var r2Client = null;
+var r2Config = null;
+function getConfig() {
+  if (r2Config) return r2Config;
+  const accountId = process.env.R2_ACCOUNT_ID;
+  const accessKeyId = process.env.R2_ACCESS_KEY_ID;
+  const secretAccessKey = process.env.R2_SECRET_ACCESS_KEY;
+  const bucketName = process.env.R2_BUCKET_NAME;
+  if (!accountId || !accessKeyId || !secretAccessKey || !bucketName) {
+    return null;
+  }
+  r2Config = {
+    accountId,
+    accessKeyId,
+    secretAccessKey,
+    bucketName,
+    publicUrl: process.env.R2_PUBLIC_URL
+  };
+  return r2Config;
+}
+function getClient() {
+  const config = getConfig();
+  if (!config) return null;
+  if (!r2Client) {
+    r2Client = new S3Client({
+      region: "auto",
+      endpoint: `https://${config.accountId}.r2.cloudflarestorage.com`,
+      credentials: {
+        accessKeyId: config.accessKeyId,
+        secretAccessKey: config.secretAccessKey
+      }
+    });
+  }
+  return r2Client;
+}
+function isR2Enabled() {
+  return getConfig() !== null;
+}
+async function uploadToR2(key, body, contentType) {
+  const client = getClient();
+  const config = getConfig();
+  if (!client || !config) {
+    throw new Error("R2 storage is not configured");
+  }
+  await client.send(
+    new PutObjectCommand({
+      Bucket: config.bucketName,
+      Key: key,
+      Body: body,
+      ContentType: contentType
+    })
+  );
+  const url = config.publicUrl ? `${config.publicUrl.replace(/\/$/, "")}/${key}` : `https://${config.bucketName}.${config.accountId}.r2.cloudflarestorage.com/${key}`;
+  return {
+    key,
+    url,
+    size: body.length
+  };
+}
+async function deleteFromR2(key) {
+  const client = getClient();
+  const config = getConfig();
+  if (!client || !config) {
+    throw new Error("R2 storage is not configured");
+  }
+  await client.send(
+    new DeleteObjectCommand({
+      Bucket: config.bucketName,
+      Key: key
+    })
+  );
+}
+async function getFromR2(key) {
+  const client = getClient();
+  const config = getConfig();
+  if (!client || !config) {
+    throw new Error("R2 storage is not configured");
+  }
+  try {
+    const response = await client.send(
+      new GetObjectCommand({
+        Bucket: config.bucketName,
+        Key: key
+      })
+    );
+    if (!response.Body) return null;
+    return {
+      body: response.Body,
+      contentType: response.ContentType || "application/octet-stream"
+    };
+  } catch (error) {
+    if (error.name === "NoSuchKey") return null;
+    throw error;
+  }
+}
+export {
+  deleteFromR2,
+  getFromR2,
+  isR2Enabled,
+  uploadToR2
+};

package/dist/system/cpu.d.ts

@@ -0,0 +1,2 @@
+import { ICpuInfo } from './types';
+export declare function getCpuInfo(): Promise<ICpuInfo>;

package/dist/system/cpu.js

@@ -0,0 +1,9 @@
+import {
+  getCpuInfo
+} from "../chunk-L76O3X3D.js";
+import "../chunk-KWTBD4CM.js";
+import "../chunk-EZR55KV2.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  getCpuInfo
+};

package/dist/system/disk.d.ts

@@ -0,0 +1,2 @@
+import { IDiskInfo } from './types';
+export declare function getDiskInfo(): Promise<IDiskInfo>;

package/dist/system/disk.js

@@ -0,0 +1,9 @@
+import {
+  getDiskInfo
+} from "../chunk-4DPSCTX4.js";
+import "../chunk-KWTBD4CM.js";
+import "../chunk-EZR55KV2.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  getDiskInfo
+};

package/dist/system/environment.d.ts

@@ -0,0 +1,8 @@
+/**
+ * environment
+ *
+ * environment
+ * - System
+ */
+import { IEnvironmentInfo } from './types';
+export declare function checkEnvironmentVariables(): IEnvironmentInfo[];

package/dist/system/environment.js

@@ -0,0 +1,9 @@
+import {
+  checkEnvironmentVariables
+} from "../chunk-26Y7VEYG.js";
+import "../chunk-KWTBD4CM.js";
+import "../chunk-EZR55KV2.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  checkEnvironmentVariables
+};

package/dist/system/health-check.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Health Check
+ *
+ * 외부 서비스 연결 상태 확인
+ * - Database (Prisma)
+ * - Redis (Cache)
+ *
+ * ⚠️ CONDITIONAL: prismaClient가 제공되지 않으면 DB 체크 스킵
+ */
+import { IServiceInfo } from './types';
+/**
+ * 서비스 헬스 체크
+ *
+ * @param prismaClient - Prisma 클라이언트 (선택사항)
+ * @returns 서비스 상태 정보 배열
+ *
+ * @example
+ * ```typescript
+ * // From your project
+ * import { checkServiceHealth } from '@withwiz/system/health-check';
+ * import { prisma } from '<your-project>/prisma';
+ *
+ * const status = await checkServiceHealth(prisma);
+ * ```
+ */
+export declare function checkServiceHealth(prismaClient?: any): Promise<IServiceInfo[]>;

package/dist/system/health-check.js

@@ -0,0 +1,10 @@
+import {
+  checkServiceHealth
+} from "../chunk-WHR7HPWF.js";
+import "../chunk-OIVXOT2X.js";
+import "../chunk-KWTBD4CM.js";
+import "../chunk-EZR55KV2.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  checkServiceHealth
+};

package/dist/system/index.d.ts

@@ -0,0 +1,51 @@
+/**
+ * index
+ *
+ * index
+ * - System
+ */
+import { ISystemInfo } from './types';
+/**
+ * 전체 시스템 정보를 수집하는 메인 함수
+ * Linux와 macOS 플랫폼별로 최적화된 시스템 리소스 조회
+ */
+export declare function getSystemInfo(): Promise<ISystemInfo>;
+/**
+ * 시스템 정보를 간단한 형태로 반환하는 함수
+ */
+export declare function getSimpleSystemInfo(): Promise<{
+    platform: string;
+    cpu: {
+        usage: string;
+        cores: number;
+        load: string;
+    };
+    memory: {
+        total: string;
+        used: string;
+        percent: string;
+    };
+    disk: {
+        total: string;
+        used: string;
+        percent: string;
+    };
+    timestamp: string;
+    error?: undefined;
+} | {
+    platform: string;
+    error: string;
+    timestamp: string;
+    cpu?: undefined;
+    memory?: undefined;
+    disk?: undefined;
+}>;
+/**
+ * 특정 시스템 리소스만 조회하는 함수들
+ */
+export { getCpuInfo } from './cpu';
+export { getMemoryInfo } from './memory';
+export { getDiskInfo } from './disk';
+export { getNetworkInfo } from './network';
+export { checkEnvironmentVariables } from './environment';
+export { checkServiceHealth } from './health-check';

package/dist/system/index.js

@@ -0,0 +1,194 @@
+import {
+  getDiskInfo
+} from "../chunk-4DPSCTX4.js";
+import {
+  checkEnvironmentVariables
+} from "../chunk-26Y7VEYG.js";
+import {
+  checkServiceHealth
+} from "../chunk-WHR7HPWF.js";
+import "../chunk-OIVXOT2X.js";
+import {
+  getMemoryInfo
+} from "../chunk-G4NI37NN.js";
+import {
+  getNetworkInfo
+} from "../chunk-65LHDFU3.js";
+import {
+  getCpuInfo
+} from "../chunk-L76O3X3D.js";
+import {
+  getPlatform,
+  getRecommendedCommands
+} from "../chunk-KWTBD4CM.js";
+import {
+  logger
+} from "../chunk-EZR55KV2.js";
+import "../chunk-ORMEWXMH.js";
+
+// src/system/index.ts
+import os from "os";
+async function getSystemInfo() {
+  try {
+    const platform = getPlatform();
+    const startTime = Date.now();
+    const recommendedCommands = getRecommendedCommands();
+    logger.debug(`[SYSTEM] Platform: ${platform}, Recommended commands:`, recommendedCommands);
+    const timeoutMs = 1e4;
+    const [cpuInfo, memoryInfo, diskInfo, networkInfo, environmentInfo, servicesInfo] = await Promise.all([
+      Promise.race([
+        getCpuInfo(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("CPU info timeout")), timeoutMs)
+        )
+      ]),
+      Promise.race([
+        getMemoryInfo(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Memory info timeout")), timeoutMs)
+        )
+      ]),
+      Promise.race([
+        getDiskInfo(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Disk info timeout")), timeoutMs)
+        )
+      ]),
+      Promise.race([
+        getNetworkInfo(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Network info timeout")), timeoutMs)
+        )
+      ]),
+      Promise.race([
+        checkEnvironmentVariables(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Environment info timeout")), timeoutMs)
+        )
+      ]),
+      Promise.race([
+        checkServiceHealth(),
+        new Promise(
+          (_, reject) => setTimeout(() => reject(new Error("Services info timeout")), timeoutMs)
+        )
+      ])
+    ]);
+    const endTime = Date.now();
+    const collectionTime = endTime - startTime;
+    const systemInfo = {
+      nodeVersion: process.version,
+      osInfo: platform === "darwin" ? "macOS" : "Linux",
+      uptime: formatUptime(process.uptime()),
+      cpu: cpuInfo,
+      memory: memoryInfo,
+      disk: diskInfo,
+      network: networkInfo,
+      environment: environmentInfo,
+      services: servicesInfo
+    };
+    logger.debug(`[SYSTEM] System info collected in ${collectionTime}ms on ${platform}`);
+    return systemInfo;
+  } catch (error) {
+    logger.error("[SYSTEM] Error collecting system info:", error);
+    return {
+      nodeVersion: process.version,
+      osInfo: getPlatform() === "darwin" ? "macOS" : "Linux",
+      uptime: formatUptime(process.uptime()),
+      cpu: {
+        system: 0,
+        processUsage: 0,
+        cores: os.cpus().length,
+        loadAverage: [0, 0, 0]
+      },
+      memory: {
+        total: 0,
+        free: 0,
+        used: 0,
+        percent: 0,
+        processUsed: 0
+      },
+      disk: {
+        total: "0 GB",
+        used: "0 GB",
+        available: "0 GB",
+        percent: 0
+      },
+      network: {
+        rxRate: "0 B/s",
+        txRate: "0 B/s",
+        processRxRate: "0 B/s",
+        processTxRate: "0 B/s",
+        connections: 0,
+        processConnections: 0
+      },
+      environment: [],
+      services: []
+    };
+  }
+}
+async function getSimpleSystemInfo() {
+  try {
+    const platform = getPlatform();
+    const cpuInfo = await getCpuInfo();
+    const memoryInfo = await getMemoryInfo();
+    const diskInfo = await getDiskInfo();
+    return {
+      platform: platform === "darwin" ? "macOS" : "Linux",
+      cpu: {
+        usage: `${cpuInfo.system}%`,
+        cores: cpuInfo.cores,
+        load: cpuInfo.loadAverage[0].toFixed(2)
+      },
+      memory: {
+        total: formatBytes(memoryInfo.total),
+        used: formatBytes(memoryInfo.used),
+        percent: `${memoryInfo.percent}%`
+      },
+      disk: {
+        total: diskInfo.total,
+        used: diskInfo.used,
+        percent: `${diskInfo.percent}%`
+      },
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch (error) {
+    logger.error("[SYSTEM] Error collecting simple system info:", error);
+    return {
+      platform: getPlatform() === "darwin" ? "macOS" : "Linux",
+      error: "Failed to collect system info",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+}
+function formatUptime(seconds) {
+  const days = Math.floor(seconds / 86400);
+  const hours = Math.floor(seconds % 86400 / 3600);
+  const minutes = Math.floor(seconds % 3600 / 60);
+  const secs = Math.floor(seconds % 60);
+  if (days > 0) {
+    return `${days}d ${hours}h ${minutes}m ${secs}s`;
+  } else if (hours > 0) {
+    return `${hours}h ${minutes}m ${secs}s`;
+  } else if (minutes > 0) {
+    return `${minutes}m ${secs}s`;
+  } else {
+    return `${secs}s`;
+  }
+}
+function formatBytes(bytes) {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB", "TB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+}
+export {
+  checkEnvironmentVariables,
+  checkServiceHealth,
+  getCpuInfo,
+  getDiskInfo,
+  getMemoryInfo,
+  getNetworkInfo,
+  getSimpleSystemInfo,
+  getSystemInfo
+};

package/dist/system/memory.d.ts

@@ -0,0 +1,2 @@
+import { IMemoryInfo } from './types';
+export declare function getMemoryInfo(): Promise<IMemoryInfo>;

package/dist/system/memory.js

@@ -0,0 +1,9 @@
+import {
+  getMemoryInfo
+} from "../chunk-G4NI37NN.js";
+import "../chunk-KWTBD4CM.js";
+import "../chunk-EZR55KV2.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  getMemoryInfo
+};

package/dist/system/network.d.ts

@@ -0,0 +1,2 @@
+import { INetworkInfo } from './types';
+export declare function getNetworkInfo(): Promise<INetworkInfo>;

package/dist/system/network.js

@@ -0,0 +1,9 @@
+import {
+  getNetworkInfo
+} from "../chunk-65LHDFU3.js";
+import "../chunk-KWTBD4CM.js";
+import "../chunk-EZR55KV2.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  getNetworkInfo
+};

package/dist/system/types.d.ts

@@ -0,0 +1,93 @@
+/**
+ * types
+ *
+ * types
+ * - System
+ */
+export interface ISystemInfo {
+    nodeVersion: string;
+    osInfo: string;
+    uptime: string;
+    cpu: {
+        system: number;
+        processUsage: number;
+        cores: number;
+        loadAverage: number[];
+    };
+    memory: {
+        total: number;
+        free: number;
+        used: number;
+        percent: number;
+        processUsed: number;
+    };
+    disk: {
+        total: string;
+        used: string;
+        available: string;
+        percent: number;
+    };
+    network: {
+        rxRate: string;
+        txRate: string;
+        processRxRate: string;
+        processTxRate: string;
+        connections: number;
+        processConnections: number;
+    };
+    environment: {
+        key: string;
+        ok: boolean;
+        value?: string;
+    }[];
+    services: {
+        name: string;
+        status: 'ok' | 'warning' | 'error';
+        message: string;
+        metrics: {
+            label: string;
+            value: string;
+        }[];
+    }[];
+}
+export interface ICpuInfo {
+    system: number;
+    processUsage: number;
+    cores: number;
+    loadAverage: number[];
+}
+export interface IMemoryInfo {
+    total: number;
+    free: number;
+    used: number;
+    percent: number;
+    processUsed: number;
+}
+export interface IDiskInfo {
+    total: string;
+    used: string;
+    available: string;
+    percent: number;
+}
+export interface INetworkInfo {
+    rxRate: string;
+    txRate: string;
+    processRxRate: string;
+    processTxRate: string;
+    connections: number;
+    processConnections: number;
+}
+export interface IEnvironmentInfo {
+    key: string;
+    ok: boolean;
+    value?: string;
+}
+export interface IServiceInfo {
+    name: string;
+    status: 'ok' | 'warning' | 'error';
+    message: string;
+    metrics: {
+        label: string;
+        value: string;
+    }[];
+}

package/dist/system/utils.d.ts

@@ -0,0 +1,12 @@
+export declare function getPlatform(): string;
+export declare function runCommand(command: string): Promise<string>;
+export declare function runMacCommand(command: string): Promise<string>;
+export declare function runPlatformCommand(command: string): Promise<string>;
+export declare function formatBytesPerSec(bytesPerSec: number): string;
+export declare function convertToBytes(value: number, unit: string): number;
+export declare function runCommandWithTimeout(command: string, timeoutMs?: number): Promise<string>;
+export declare function runSafeCommand(command: string, fallbackCommand?: string): Promise<string>;
+export declare function commandExists(command: string): Promise<boolean>;
+export declare function getRecommendedCommands(): {
+    [key: string]: string[];
+};

package/dist/system/utils.js

@@ -0,0 +1,26 @@
+import {
+  commandExists,
+  convertToBytes,
+  formatBytesPerSec,
+  getPlatform,
+  getRecommendedCommands,
+  runCommand,
+  runCommandWithTimeout,
+  runMacCommand,
+  runPlatformCommand,
+  runSafeCommand
+} from "../chunk-KWTBD4CM.js";
+import "../chunk-EZR55KV2.js";
+import "../chunk-ORMEWXMH.js";
+export {
+  commandExists,
+  convertToBytes,
+  formatBytesPerSec,
+  getPlatform,
+  getRecommendedCommands,
+  runCommand,
+  runCommandWithTimeout,
+  runMacCommand,
+  runPlatformCommand,
+  runSafeCommand
+};