@mushi-mushi/core 0.1.0

package/dist/index.js

@@ -0,0 +1,668 @@
+// src/api-client.ts
+var DEFAULT_API_ENDPOINT = "https://api.mushimushi.dev";
+var DEFAULT_TIMEOUT = 1e4;
+var DEFAULT_MAX_RETRIES = 2;
+function createApiClient(options) {
+  const {
+    projectId,
+    apiKey,
+    apiEndpoint = DEFAULT_API_ENDPOINT,
+    timeout = DEFAULT_TIMEOUT,
+    maxRetries = DEFAULT_MAX_RETRIES
+  } = options;
+  const baseUrl = apiEndpoint.replace(/\/$/, "");
+  async function request(method, path, body, retries = maxRetries) {
+    const url = `${baseUrl}${path}`;
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, {
+        method,
+        headers: {
+          "Content-Type": "application/json",
+          "X-Mushi-Api-Key": apiKey,
+          "X-Mushi-Project": projectId
+        },
+        body: body ? JSON.stringify(body) : void 0,
+        signal: controller.signal
+      });
+      clearTimeout(timer);
+      if (!response.ok) {
+        const errorBody = await response.json().catch(() => ({}));
+        if (response.status >= 500 && retries > 0) {
+          await sleep(getBackoffDelay(maxRetries - retries));
+          return request(method, path, body, retries - 1);
+        }
+        return {
+          ok: false,
+          error: {
+            code: `HTTP_${response.status}`,
+            message: errorBody.message || `HTTP ${response.status} error`
+          }
+        };
+      }
+      const data = await response.json();
+      return { ok: true, data };
+    } catch (error) {
+      clearTimeout(timer);
+      if (retries > 0 && isRetryable(error)) {
+        await sleep(getBackoffDelay(maxRetries - retries));
+        return request(method, path, body, retries - 1);
+      }
+      return {
+        ok: false,
+        error: {
+          code: "NETWORK_ERROR",
+          message: error instanceof Error ? error.message : "Unknown network error"
+        }
+      };
+    }
+  }
+  return {
+    async submitReport(report) {
+      return request("POST", "/v1/reports", report);
+    },
+    async getReportStatus(reportId) {
+      return request("GET", `/v1/reports/${reportId}/status`);
+    }
+  };
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getBackoffDelay(attempt) {
+  return Math.min(1e3 * 2 ** attempt + Math.random() * 500, 1e4);
+}
+function isRetryable(error) {
+  if (error instanceof DOMException && error.name === "AbortError") return true;
+  if (error instanceof TypeError) return true;
+  return false;
+}
+
+// src/pre-filter.ts
+var DEFAULT_MIN_LENGTH = 10;
+var DEFAULT_MAX_LENGTH = 2e3;
+var SPAM_PATTERNS = [
+  /^(.)\1{10,}$/,
+  // repeated single character
+  /^[A-Z\s!?]{20,}$/,
+  // all caps shouting
+  /^[\d\s]+$/,
+  // numbers only
+  /^[^a-zA-Z\u00C0-\u024F\u4E00-\u9FFF\u3040-\u309F\u30A0-\u30FF]{10,}$/,
+  // no real letters
+  /\b(test|asdf|qwerty|lorem ipsum)\b/i
+  // common test strings
+];
+var GIBBERISH_PATTERN = /^[bcdfghjklmnpqrstvwxz]{6,}/i;
+function createPreFilter(config = {}) {
+  const {
+    enabled = true,
+    blockObviousSpam = true,
+    minDescriptionLength = DEFAULT_MIN_LENGTH,
+    maxDescriptionLength = DEFAULT_MAX_LENGTH
+  } = config;
+  function check(description) {
+    if (!enabled) {
+      return { passed: true };
+    }
+    const trimmed = description.trim();
+    if (trimmed.length < minDescriptionLength) {
+      return { passed: false, reason: `Too short (min ${minDescriptionLength} characters)` };
+    }
+    if (trimmed.length > maxDescriptionLength) {
+      return { passed: false, reason: `Too long (max ${maxDescriptionLength} characters)` };
+    }
+    if (blockObviousSpam) {
+      for (const pattern of SPAM_PATTERNS) {
+        if (pattern.test(trimmed)) {
+          return { passed: false, reason: "Detected as spam" };
+        }
+      }
+      if (GIBBERISH_PATTERN.test(trimmed)) {
+        return { passed: false, reason: "Detected as gibberish" };
+      }
+      const words = trimmed.split(/\s+/).filter((w) => w.length > 1);
+      if (words.length < 2) {
+        return { passed: false, reason: "Description needs at least 2 words" };
+      }
+    }
+    return { passed: true };
+  }
+  function truncate(description) {
+    const trimmed = description.trim();
+    if (trimmed.length <= maxDescriptionLength) return trimmed;
+    return trimmed.slice(0, maxDescriptionLength) + "...";
+  }
+  return { check, truncate };
+}
+
+// src/logger.ts
+var LEVEL_VALUE = {
+  debug: 10,
+  info: 20,
+  warn: 30,
+  error: 40,
+  fatal: 50,
+  silent: 99
+};
+var LEVEL_LABEL = {
+  debug: "DBG",
+  info: "INF",
+  warn: "WRN",
+  error: "ERR",
+  fatal: "FTL"
+};
+var ANSI = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m",
+  cyan: "\x1B[36m",
+  green: "\x1B[32m",
+  yellow: "\x1B[33m",
+  red: "\x1B[31m",
+  white: "\x1B[37m",
+  bgRed: "\x1B[41m"
+};
+var LEVEL_COLOR = {
+  debug: ANSI.dim,
+  info: ANSI.green,
+  warn: ANSI.yellow,
+  error: ANSI.red,
+  fatal: `${ANSI.bgRed}${ANSI.white}${ANSI.bold}`
+};
+function detectFormat() {
+  try {
+    if (typeof globalThis.Deno !== "undefined") return "json";
+  } catch {
+  }
+  const proc = typeof globalThis.process !== "undefined" ? globalThis.process : void 0;
+  if (proc?.env) {
+    if (proc.env.NODE_ENV === "production") return "json";
+    if (proc.env.LOG_FORMAT === "json") return "json";
+    if (proc.env.LOG_FORMAT === "pretty") return "pretty";
+    if (proc.stdout?.isTTY) return "pretty";
+  }
+  if (typeof globalThis.window !== "undefined") return "pretty";
+  return "json";
+}
+function flattenMeta(meta) {
+  const parts = [];
+  for (const [k, v] of Object.entries(meta)) {
+    if (v === void 0 || v === null) continue;
+    if (typeof v === "object") {
+      parts.push(`${k}=${JSON.stringify(v)}`);
+    } else {
+      parts.push(`${k}=${String(v)}`);
+    }
+  }
+  return parts.join(" ");
+}
+function formatPretty(entry) {
+  const { ts, level, scope, msg, ...rest } = entry;
+  const time = ts.slice(11, 23);
+  const color = LEVEL_COLOR[level] ?? "";
+  const label = LEVEL_LABEL[level] ?? level.toUpperCase();
+  const metaStr = Object.keys(rest).length > 0 ? ` ${ANSI.dim}${flattenMeta(rest)}${ANSI.reset}` : "";
+  return `${ANSI.dim}${time}${ANSI.reset} ${color}${label}${ANSI.reset} ${ANSI.cyan}[${scope}]${ANSI.reset} ${msg}${metaStr}`;
+}
+function formatJson(entry) {
+  return JSON.stringify(entry);
+}
+function emit(level, formatted) {
+  switch (level) {
+    case "error":
+    case "fatal":
+      console.error(formatted);
+      break;
+    case "warn":
+      console.warn(formatted);
+      break;
+    default:
+      console.log(formatted);
+  }
+}
+function buildLogger(scope, minLevel, baseMeta, formatter) {
+  let currentLevel = minLevel;
+  function log(level, msg, meta) {
+    if (LEVEL_VALUE[level] < LEVEL_VALUE[currentLevel]) return;
+    const entry = {
+      ts: (/* @__PURE__ */ new Date()).toISOString(),
+      level,
+      scope,
+      msg,
+      ...baseMeta,
+      ...meta
+    };
+    emit(level, formatter(entry));
+  }
+  return {
+    debug: (msg, meta) => log("debug", msg, meta),
+    info: (msg, meta) => log("info", msg, meta),
+    warn: (msg, meta) => log("warn", msg, meta),
+    error: (msg, meta) => log("error", msg, meta),
+    fatal: (msg, meta) => log("fatal", msg, meta),
+    child(childScope, childMeta) {
+      return buildLogger(
+        `${scope}:${childScope}`,
+        currentLevel,
+        { ...baseMeta, ...childMeta },
+        formatter
+      );
+    },
+    setLevel(level) {
+      currentLevel = level;
+    }
+  };
+}
+function createLogger(options) {
+  const {
+    scope,
+    level = "info",
+    meta = {},
+    format = "auto"
+  } = options;
+  const resolvedFormat = format === "auto" ? detectFormat() : format;
+  const formatter = resolvedFormat === "json" ? formatJson : formatPretty;
+  return buildLogger(scope, level, meta, formatter);
+}
+var noopLogger = {
+  debug: () => {
+  },
+  info: () => {
+  },
+  warn: () => {
+  },
+  error: () => {
+  },
+  fatal: () => {
+  },
+  child: () => noopLogger,
+  setLevel: () => {
+  }
+};
+
+// src/queue.ts
+var queueLog = createLogger({ scope: "mushi:queue", level: "warn" });
+var DB_NAME = "mushi-mushi";
+var STORE_NAME = "offline-reports";
+var DB_VERSION = 1;
+var LS_KEY = "mushi_offline_queue";
+var BATCH_SIZE = 10;
+var MAX_BACKOFF_MS = 6e4;
+function createOfflineQueue(config = {}) {
+  const { enabled = true, maxQueueSize = 50, syncOnReconnect = true } = config;
+  let syncCleanup = null;
+  let backendType = null;
+  function detectBackend() {
+    if (backendType) return backendType;
+    if (typeof indexedDB !== "undefined") {
+      backendType = "indexeddb";
+    } else if (typeof localStorage !== "undefined") {
+      backendType = "localstorage";
+    } else {
+      backendType = "none";
+    }
+    return backendType;
+  }
+  function openDb() {
+    return new Promise((resolve, reject) => {
+      const request = indexedDB.open(DB_NAME, DB_VERSION);
+      request.onupgradeneeded = () => {
+        const db = request.result;
+        if (!db.objectStoreNames.contains(STORE_NAME)) {
+          db.createObjectStore(STORE_NAME, { keyPath: "id" });
+        }
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => {
+        backendType = "localstorage";
+        reject(request.error);
+      };
+    });
+  }
+  async function idbEnqueue(report) {
+    const db = await openDb();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readwrite");
+      tx.objectStore(STORE_NAME).put({ ...report, queuedAt: (/* @__PURE__ */ new Date()).toISOString() });
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async function idbGetAll() {
+    const db = await openDb();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readonly");
+      const request = tx.objectStore(STORE_NAME).getAll();
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async function idbDelete(id) {
+    const db = await openDb();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readwrite");
+      tx.objectStore(STORE_NAME).delete(id);
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  async function idbSize() {
+    const db = await openDb();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readonly");
+      const request = tx.objectStore(STORE_NAME).count();
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error);
+    });
+  }
+  async function idbClear() {
+    const db = await openDb();
+    return new Promise((resolve, reject) => {
+      const tx = db.transaction(STORE_NAME, "readwrite");
+      tx.objectStore(STORE_NAME).clear();
+      tx.oncomplete = () => resolve();
+      tx.onerror = () => reject(tx.error);
+    });
+  }
+  function lsRead() {
+    try {
+      const raw = localStorage.getItem(LS_KEY);
+      return raw ? JSON.parse(raw) : [];
+    } catch {
+      return [];
+    }
+  }
+  function lsWrite(reports) {
+    try {
+      localStorage.setItem(LS_KEY, JSON.stringify(reports));
+    } catch {
+    }
+  }
+  function lsEnqueue(report) {
+    const reports = lsRead();
+    reports.push({ ...report, queuedAt: (/* @__PURE__ */ new Date()).toISOString() });
+    lsWrite(reports);
+  }
+  function lsDelete(id) {
+    const reports = lsRead().filter((r) => r.id !== id);
+    lsWrite(reports);
+  }
+  async function enqueue(report) {
+    if (!enabled) return;
+    const currentSize = await size();
+    if (currentSize >= maxQueueSize) {
+      queueLog.warn("Offline queue full \u2014 dropping report", { maxQueueSize });
+      return;
+    }
+    const backend = detectBackend();
+    if (backend === "indexeddb") {
+      try {
+        await idbEnqueue(report);
+        return;
+      } catch {
+        backendType = "localstorage";
+      }
+    }
+    if (backend === "localstorage" || backendType === "localstorage") {
+      lsEnqueue(report);
+      return;
+    }
+  }
+  function getBackoffDelay2(attempt) {
+    return Math.min(1e3 * 2 ** attempt + Math.random() * 500, MAX_BACKOFF_MS);
+  }
+  function sleep2(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async function flush(client) {
+    if (!enabled) return { sent: 0, failed: 0 };
+    let reports;
+    const backend = detectBackend();
+    if (backend === "indexeddb") {
+      try {
+        reports = await idbGetAll();
+      } catch {
+        reports = lsRead();
+      }
+    } else {
+      reports = lsRead();
+    }
+    const batch = reports.slice(0, BATCH_SIZE);
+    let sent = 0;
+    let failed = 0;
+    for (let i = 0; i < batch.length; i++) {
+      const report = batch[i];
+      const result = await client.submitReport(report);
+      if (result.ok) {
+        try {
+          if (backend === "indexeddb") await idbDelete(report.id);
+          else lsDelete(report.id);
+        } catch {
+          lsDelete(report.id);
+        }
+        sent++;
+      } else {
+        failed++;
+        if (i < batch.length - 1) {
+          await sleep2(getBackoffDelay2(i));
+        }
+      }
+    }
+    return { sent, failed };
+  }
+  async function size() {
+    const backend = detectBackend();
+    if (backend === "indexeddb") {
+      try {
+        return await idbSize();
+      } catch {
+        return lsRead().length;
+      }
+    }
+    return lsRead().length;
+  }
+  async function clear() {
+    const backend = detectBackend();
+    if (backend === "indexeddb") {
+      try {
+        await idbClear();
+      } catch {
+      }
+    }
+    try {
+      localStorage.removeItem(LS_KEY);
+    } catch {
+    }
+  }
+  function startAutoSync(client) {
+    if (!enabled || !syncOnReconnect || typeof window === "undefined") return;
+    const handler = () => {
+      if (navigator.onLine) {
+        flush(client).catch(() => {
+        });
+      }
+    };
+    window.addEventListener("online", handler);
+    syncCleanup = () => window.removeEventListener("online", handler);
+  }
+  function stopAutoSync() {
+    syncCleanup?.();
+    syncCleanup = null;
+  }
+  return { enqueue, flush, size, clear, startAutoSync, stopAutoSync };
+}
+
+// src/environment.ts
+function captureEnvironment() {
+  const nav = typeof navigator !== "undefined" ? navigator : void 0;
+  const win = typeof window !== "undefined" ? window : void 0;
+  const doc = typeof document !== "undefined" ? document : void 0;
+  const connection = nav && "connection" in nav ? nav.connection : void 0;
+  return {
+    userAgent: nav?.userAgent ?? "unknown",
+    platform: nav?.platform ?? "unknown",
+    language: nav?.language ?? "en",
+    viewport: {
+      width: win?.innerWidth ?? 0,
+      height: win?.innerHeight ?? 0
+    },
+    url: win?.location?.href ?? "",
+    referrer: doc?.referrer ?? "",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    timezone: Intl?.DateTimeFormat?.()?.resolvedOptions?.()?.timeZone ?? "UTC",
+    connection: connection ? {
+      effectiveType: connection.effectiveType,
+      downlink: connection.downlink,
+      rtt: connection.rtt
+    } : void 0,
+    deviceMemory: nav?.deviceMemory,
+    hardwareConcurrency: nav?.hardwareConcurrency
+  };
+}
+
+// src/reporter-token.ts
+var STORAGE_KEY = "mushi_reporter_token";
+function getReporterToken() {
+  if (typeof localStorage !== "undefined") {
+    const existing = localStorage.getItem(STORAGE_KEY);
+    if (existing) return existing;
+  }
+  const token = generateToken();
+  if (typeof localStorage !== "undefined") {
+    try {
+      localStorage.setItem(STORAGE_KEY, token);
+    } catch {
+    }
+  }
+  return token;
+}
+function generateToken() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return `mushi_${crypto.randomUUID()}`;
+  }
+  const bytes = new Uint8Array(16);
+  if (typeof crypto !== "undefined") {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  const hex = Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+  return `mushi_${hex}`;
+}
+
+// src/session.ts
+var SESSION_KEY = "mushi_session_id";
+var cachedSessionId = null;
+function getSessionId() {
+  if (cachedSessionId) return cachedSessionId;
+  if (typeof sessionStorage !== "undefined") {
+    const existing = sessionStorage.getItem(SESSION_KEY);
+    if (existing) {
+      cachedSessionId = existing;
+      return existing;
+    }
+  }
+  const id = generateSessionId();
+  cachedSessionId = id;
+  if (typeof sessionStorage !== "undefined") {
+    try {
+      sessionStorage.setItem(SESSION_KEY, id);
+    } catch {
+    }
+  }
+  return id;
+}
+function generateSessionId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).slice(2, 8);
+  return `ms_${timestamp}_${random}`;
+}
+
+// src/rate-limiter.ts
+var DEFAULT_MAX_BURST = 10;
+var DEFAULT_REFILL_RATE = 1;
+var DEFAULT_REFILL_INTERVAL_MS = 5e3;
+function createRateLimiter(config = {}) {
+  const {
+    maxBurst = DEFAULT_MAX_BURST,
+    refillRate = DEFAULT_REFILL_RATE,
+    refillIntervalMs = DEFAULT_REFILL_INTERVAL_MS
+  } = config;
+  let tokens = maxBurst;
+  let lastRefill = Date.now();
+  function refill() {
+    const now = Date.now();
+    const elapsed = now - lastRefill;
+    const refills = Math.floor(elapsed / refillIntervalMs);
+    if (refills > 0) {
+      tokens = Math.min(maxBurst, tokens + refills * refillRate);
+      lastRefill = now;
+    }
+  }
+  function tryConsume() {
+    refill();
+    if (tokens > 0) {
+      tokens--;
+      return true;
+    }
+    return false;
+  }
+  function reset() {
+    tokens = maxBurst;
+    lastRefill = Date.now();
+  }
+  function availableTokens() {
+    refill();
+    return tokens;
+  }
+  return { tryConsume, reset, availableTokens };
+}
+
+// src/pii-scrubber.ts
+var ORDERED_PATTERNS = [
+  { key: "ssns", regex: /\b\d{3}-\d{2}-\d{4}\b/g, replacement: "[REDACTED_SSN]" },
+  { key: "creditCards", regex: /\b(?:\d[ -]*){12,18}\d\b/g, replacement: "[REDACTED_CC]" },
+  { key: "emails", regex: /\b[A-Za-z0-9._%+\-]+@[A-Za-z0-9.\-]+\.[A-Za-z]{2,}\b/g, replacement: "[REDACTED_EMAIL]" },
+  { key: "phones", regex: /(?:\+\d{1,3}[\s.-])?\(?\d{2,4}\)?[\s.-]\d{3,4}[\s.-]\d{3,4}\b/g, replacement: "[REDACTED_PHONE]" },
+  { key: "ipAddresses", regex: /\b(?:\d{1,3}\.){3}\d{1,3}\b/g, replacement: "[REDACTED_IP]" }
+];
+var DEFAULT_CONFIG = {
+  emails: true,
+  phones: true,
+  creditCards: true,
+  ssns: true,
+  ipAddresses: false
+};
+function createPiiScrubber(config = {}) {
+  const merged = { ...DEFAULT_CONFIG, ...config };
+  const activePatterns = ORDERED_PATTERNS.filter((p) => merged[p.key]);
+  function scrub(text) {
+    if (!text) return text;
+    let result = text;
+    for (const { regex, replacement } of activePatterns) {
+      result = result.replace(new RegExp(regex.source, regex.flags), replacement);
+    }
+    return result;
+  }
+  function scrubObject(obj, keys) {
+    const copy = { ...obj };
+    for (const key of keys) {
+      if (typeof copy[key] === "string") {
+        copy[key] = scrub(copy[key]);
+      }
+    }
+    return copy;
+  }
+  return { scrub, scrubObject };
+}
+function scrubPii(text, config) {
+  return createPiiScrubber(config).scrub(text);
+}
+
+export { captureEnvironment, createApiClient, createLogger, createOfflineQueue, createPiiScrubber, createPreFilter, createRateLimiter, getReporterToken, getSessionId, noopLogger, scrubPii };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map