@bike4mind/cli 0.2.64-worktree-refactor-extract-search-query-builders.21815 → 0.2.64

package/dist/bashExecute-GLGLD3JD.js

@@ -1,379 +0,0 @@
-#!/usr/bin/env node
-
-// ../../b4m-core/packages/services/dist/src/llm/tools/implementation/bashExecute/index.js
-import { spawn } from "child_process";
-import path from "path";
-var DEFAULT_TIMEOUT_MS = 6e4;
-var MAX_OUTPUT_SIZE = 100 * 1024;
-var DANGEROUS_PATTERNS = [
-  // Destructive file operations
-  {
-    pattern: /\brm\s+(-[a-zA-Z]*r[a-zA-Z]*\s+|.*\s+-[a-zA-Z]*r).*\//i,
-    reason: "Recursive delete with path",
-    block: true
-  },
-  {
-    pattern: /\brm\s+(-[a-zA-Z]*f[a-zA-Z]*\s+|.*\s+-[a-zA-Z]*f).*--no-preserve-root/i,
-    reason: "Force delete without preserve root",
-    block: true
-  },
-  {
-    pattern: /\brm\s+-[a-zA-Z]*r[a-zA-Z]*f[a-zA-Z]*\s+\//i,
-    reason: "Recursive force delete on root paths",
-    block: true
-  },
-  {
-    pattern: /\brm\s+-[a-zA-Z]*f[a-zA-Z]*r[a-zA-Z]*\s+\//i,
-    reason: "Force recursive delete on root paths",
-    block: true
-  },
-  // System-level dangerous commands
-  { pattern: /\bsudo\b/i, reason: "Elevated privileges (sudo)", block: true },
-  { pattern: /\bsu\s+(-|root)/i, reason: "Switch to root user", block: true },
-  { pattern: /\bchmod\s+777\b/i, reason: "Overly permissive chmod", block: false },
-  { pattern: /\bchown\s+-R\s+root/i, reason: "Recursive chown to root", block: true },
-  // Disk/partition operations
-  { pattern: /\bmkfs\b/i, reason: "Filesystem creation", block: true },
-  { pattern: /\bfdisk\b/i, reason: "Disk partitioning", block: true },
-  { pattern: /\bdd\s+.*of=\/dev\//i, reason: "Direct disk write", block: true },
-  // Network attacks
-  { pattern: /\b(nc|netcat)\s+.*-e\s+\/bin\/(ba)?sh/i, reason: "Reverse shell attempt", block: true },
-  { pattern: /\bcurl\s+.*\|\s*(ba)?sh/i, reason: "Piping remote script to shell", block: true },
-  { pattern: /\bwget\s+.*\|\s*(ba)?sh/i, reason: "Piping remote script to shell", block: true },
-  // Fork bombs and resource exhaustion
-  { pattern: /:\(\)\s*\{\s*:\|:&\s*\}\s*;/i, reason: "Fork bomb", block: true },
-  { pattern: /\bwhile\s+true.*do.*done.*&/i, reason: "Infinite loop in background", block: false },
-  // Credential/sensitive data access
-  { pattern: /\/etc\/shadow/i, reason: "Access to shadow file", block: true },
-  { pattern: /\/etc\/passwd.*>/i, reason: "Modifying passwd file", block: true },
-  { pattern: /\baws\s+.*--profile\s+/i, reason: "AWS profile access", block: false },
-  // History/log manipulation
-  { pattern: /\bhistory\s+-c\b/i, reason: "Clearing shell history", block: false },
-  { pattern: />\s*\/var\/log\//i, reason: "Overwriting system logs", block: true },
-  // Dangerous redirects
-  { pattern: />\s*\/dev\/sda/i, reason: "Writing to block device", block: true },
-  { pattern: />\s*\/dev\/null.*2>&1.*</i, reason: "Potentially hiding output", block: false },
-  // Environment manipulation
-  { pattern: /\bexport\s+PATH\s*=\s*[^$]/i, reason: "Overwriting PATH", block: false },
-  { pattern: /\bexport\s+LD_PRELOAD/i, reason: "LD_PRELOAD manipulation", block: true },
-  // Process/system control
-  { pattern: /\bkill\s+-9\s+(-1|1)\b/i, reason: "Killing all processes", block: true },
-  { pattern: /\bkillall\s+-9\b/i, reason: "Force killing processes", block: false },
-  { pattern: /\bshutdown\b/i, reason: "System shutdown", block: true },
-  { pattern: /\breboot\b/i, reason: "System reboot", block: true },
-  { pattern: /\binit\s+[06]\b/i, reason: "System runlevel change", block: true }
-];
-var SAFE_COMMAND_PREFIXES = [
-  "ls",
-  "cat",
-  "head",
-  "tail",
-  "grep",
-  "find",
-  "echo",
-  "pwd",
-  "whoami",
-  "date",
-  "cal",
-  "wc",
-  "sort",
-  "uniq",
-  "cut",
-  "tr",
-  "sed",
-  "awk",
-  "git",
-  "npm",
-  "pnpm",
-  "yarn",
-  "node",
-  "npx",
-  "tsx",
-  "ts-node",
-  "python",
-  "python3",
-  "pip",
-  "pip3",
-  "docker",
-  "docker-compose",
-  "curl",
-  "wget",
-  // These are safe for fetching, blocked when piped to shell
-  "mkdir",
-  "touch",
-  "cp",
-  "mv",
-  // File operations (still require permission)
-  "which",
-  "whereis",
-  "type",
-  "file",
-  "stat",
-  "env",
-  "printenv",
-  "set",
-  "man",
-  "help",
-  "info",
-  "diff",
-  "comm",
-  "cmp",
-  "tar",
-  "zip",
-  "unzip",
-  "gzip",
-  "gunzip",
-  "ssh",
-  "scp",
-  "rsync",
-  // Network tools
-  "make",
-  "cmake",
-  "cargo",
-  "go",
-  "rustc",
-  "gcc",
-  "g++",
-  // Build tools
-  "jest",
-  "vitest",
-  "mocha",
-  "pytest",
-  // Test runners
-  "eslint",
-  "prettier",
-  "tsc"
-  // Linters/formatters
-];
-function checkDangerousPatterns(command) {
-  for (const { pattern, reason, block } of DANGEROUS_PATTERNS) {
-    if (pattern.test(command)) {
-      return { blocked: block, reason };
-    }
-  }
-  return { blocked: false };
-}
-function getBaseCommand(command) {
-  const trimmed = command.trim();
-  const match = trimmed.match(/^(\S+)/);
-  return match ? match[1] : "";
-}
-function isSafeCommandPrefix(command) {
-  const baseCommand = getBaseCommand(command);
-  return SAFE_COMMAND_PREFIXES.some((safe) => baseCommand === safe || baseCommand.endsWith(`/${safe}`));
-}
-async function executeBashCommand(params) {
-  const { command, cwd: relativeCwd, timeout = DEFAULT_TIMEOUT_MS } = params;
-  if (!command || command.trim().length === 0) {
-    return {
-      stdout: "",
-      stderr: "Error: Command cannot be empty",
-      exitCode: 1,
-      timedOut: false,
-      blocked: true,
-      blockedReason: "Empty command"
-    };
-  }
-  const dangerCheck = checkDangerousPatterns(command);
-  if (dangerCheck.blocked) {
-    return {
-      stdout: "",
-      stderr: `Command blocked for safety: ${dangerCheck.reason}`,
-      exitCode: 1,
-      timedOut: false,
-      blocked: true,
-      blockedReason: dangerCheck.reason
-    };
-  }
-  const baseCwd = process.cwd();
-  const targetCwd = relativeCwd ? path.resolve(baseCwd, relativeCwd) : baseCwd;
-  const effectiveTimeout = Math.min(timeout, 5 * 60 * 1e3);
-  return new Promise((resolve) => {
-    let stdout = "";
-    let stderr = "";
-    let timedOut = false;
-    const proc = spawn("bash", ["-c", command], {
-      cwd: targetCwd,
-      env: {
-        ...process.env,
-        // Prevent color codes that might be hard to read
-        NO_COLOR: "1",
-        FORCE_COLOR: "0"
-      },
-      stdio: ["ignore", "pipe", "pipe"]
-    });
-    const timeoutId = setTimeout(() => {
-      timedOut = true;
-      proc.kill("SIGTERM");
-      setTimeout(() => {
-        if (!proc.killed) {
-          proc.kill("SIGKILL");
-        }
-      }, 5e3);
-    }, effectiveTimeout);
-    proc.stdout.on("data", (data) => {
-      if (stdout.length < MAX_OUTPUT_SIZE) {
-        stdout += data.toString();
-        if (stdout.length > MAX_OUTPUT_SIZE) {
-          stdout = stdout.slice(0, MAX_OUTPUT_SIZE) + "\n... [output truncated]";
-        }
-      }
-    });
-    proc.stderr.on("data", (data) => {
-      if (stderr.length < MAX_OUTPUT_SIZE) {
-        stderr += data.toString();
-        if (stderr.length > MAX_OUTPUT_SIZE) {
-          stderr = stderr.slice(0, MAX_OUTPUT_SIZE) + "\n... [output truncated]";
-        }
-      }
-    });
-    proc.on("close", (exitCode) => {
-      clearTimeout(timeoutId);
-      resolve({
-        stdout: stdout.trim(),
-        stderr: stderr.trim(),
-        exitCode,
-        timedOut,
-        blocked: false
-      });
-    });
-    proc.on("error", (error) => {
-      clearTimeout(timeoutId);
-      resolve({
-        stdout: "",
-        stderr: `Failed to execute command: ${error.message}`,
-        exitCode: 1,
-        timedOut: false,
-        blocked: false
-      });
-    });
-  });
-}
-function formatResult(result, command) {
-  const parts = [];
-  parts.push(`$ ${command}`);
-  parts.push("");
-  if (result.blocked) {
-    parts.push(`BLOCKED: ${result.blockedReason}`);
-    parts.push("");
-    parts.push("This command was blocked for safety reasons.");
-    parts.push("If you believe this is a false positive, please run the command manually.");
-    return parts.join("\n");
-  }
-  if (result.timedOut) {
-    parts.push("WARNING: Command timed out and was terminated.");
-    parts.push("");
-  }
-  if (result.stdout) {
-    parts.push(result.stdout);
-  }
-  if (result.stderr) {
-    if (result.stdout) {
-      parts.push("");
-    }
-    parts.push("STDERR:");
-    parts.push(result.stderr);
-  }
-  if (result.exitCode !== 0 && result.exitCode !== null) {
-    parts.push("");
-    parts.push(`Exit code: ${result.exitCode}`);
-  }
-  if (!result.stdout && !result.stderr && !result.timedOut) {
-    parts.push("(command completed with no output)");
-  }
-  return parts.join("\n");
-}
-var bashExecuteTool = {
-  name: "bash_execute",
-  implementation: (context) => ({
-    toolFn: async (value) => {
-      const params = value;
-      const isSafe = isSafeCommandPrefix(params.command);
-      context.logger.info("Bash: Executing command", {
-        command: params.command,
-        cwd: params.cwd || ".",
-        timeout: params.timeout || DEFAULT_TIMEOUT_MS,
-        isSafeCommand: isSafe
-      });
-      if (context.onStart) {
-        await context.onStart("bash_execute", {
-          command: params.command,
-          cwd: params.cwd
-        });
-      }
-      try {
-        const result = await executeBashCommand(params);
-        const formattedResult = formatResult(result, params.command);
-        context.logger.info("Bash: Command completed", {
-          exitCode: result.exitCode,
-          timedOut: result.timedOut,
-          blocked: result.blocked
-        });
-        if (context.onFinish) {
-          await context.onFinish("bash_execute", {
-            command: params.command,
-            exitCode: result.exitCode,
-            blocked: result.blocked
-          });
-        }
-        return formattedResult;
-      } catch (error) {
-        context.logger.error("Bash: Command failed", error);
-        if (context.onFinish) {
-          await context.onFinish("bash_execute", {
-            command: params.command,
-            error: error instanceof Error ? error.message : "Unknown error"
-          });
-        }
-        throw error;
-      }
-    },
-    toolSchema: {
-      name: "bash_execute",
-      description: `Execute a bash command in the terminal. Use this for running shell commands, scripts, build tools, git operations, and other CLI tasks.
-
-SAFETY NOTES:
-- Commands are executed in the current working directory (or specified cwd)
-- Dangerous commands (sudo, rm -rf /, etc.) are automatically blocked
-- Commands have a default timeout of 60 seconds (max 5 minutes)
-- Output is limited to prevent overwhelming responses
-- This tool ALWAYS requires user permission before execution
-
-COMMON USE CASES:
-- Running build commands: npm run build, make, cargo build
-- Git operations: git status, git log, git diff
-- Viewing system info: ls, pwd, cat, head, tail
-- Running tests: npm test, pytest, cargo test
-- Package management: npm install, pip install
-- File operations: mkdir, cp, mv (with permission)
-
-BLOCKED OPERATIONS:
-- sudo and privilege escalation
-- Recursive deletes on system paths
-- Direct disk operations
-- Fork bombs and resource exhaustion
-- Piping remote scripts to shell`,
-      parameters: {
-        type: "object",
-        properties: {
-          command: {
-            type: "string",
-            description: "The bash command to execute. Can include pipes, redirects, and chained commands."
-          },
-          cwd: {
-            type: "string",
-            description: "Working directory for the command (optional). Can be relative or absolute path. Defaults to current directory."
-          },
-          timeout: {
-            type: "number",
-            description: "Timeout in milliseconds (optional, default: 60000, max: 300000). Command will be terminated if it exceeds this time."
-          }
-        },
-        required: ["command"]
-      }
-    }
-  })
-};
-export {
-  bashExecuteTool
-};

package/dist/chunk-4BIBE3J7.js

@@ -1,48 +0,0 @@
-#!/usr/bin/env node
-
-// src/sandbox/types.ts
-var DEFAULT_SANDBOX_CONFIG = {
-  enabled: false,
-  mode: "disabled",
-  filesystem: {
-    writeOnlyToWorkingDir: true,
-    allowedReadPaths: ["$HOME/.gitconfig", "$HOME/.npmrc", "$HOME/.node_modules"],
-    deniedPaths: ["$HOME/.ssh", "$HOME/.aws", "$HOME/.gnupg", "$HOME/.env", "/etc/shadow", "/etc/passwd"]
-  },
-  network: {
-    enabled: false,
-    allowedDomains: [
-      "registry.npmjs.org",
-      "*.npmjs.org",
-      "pypi.org",
-      "*.pypi.org",
-      "files.pythonhosted.org",
-      "crates.io",
-      "*.crates.io",
-      "rubygems.org",
-      "github.com",
-      "*.github.com",
-      "gitlab.com",
-      "*.gitlab.com",
-      "bitbucket.org",
-      "*.bitbucket.org",
-      "*.githubusercontent.com",
-      "*.cloudflare.com"
-    ]
-  },
-  excludedCommands: ["docker", "watchman", "podman"],
-  allowUnsandboxedCommands: true,
-  platform: {
-    linux: {
-      runtime: "bubblewrap"
-    },
-    macos: {
-      runtime: "seatbelt",
-      profileTemplate: "default"
-    }
-  }
-};
-
-export {
-  DEFAULT_SANDBOX_CONFIG
-};

package/dist/chunk-5LZS5CVJ.js

@@ -1,161 +0,0 @@
-#!/usr/bin/env node
-import {
-  BadRequestError,
-  secureParameters
-} from "./chunk-EPIYC3LA.js";
-import {
-  CompletionApiUsageTransaction,
-  GenericCreditDeductTransaction,
-  ImageEditUsageTransaction,
-  ImageGenerationUsageTransaction,
-  RealtimeVoiceUsageTransaction,
-  TextGenerationUsageTransaction,
-  ToolUsageTransaction,
-  TransferCreditTransaction,
-  VideoGenerationUsageTransaction
-} from "./chunk-JW3JRHH7.js";
-
-// ../../b4m-core/packages/services/dist/src/creditService/subtractCredits.js
-import { z } from "zod";
-var SubtractCreditsSchema = z.discriminatedUnion("type", [
-  GenericCreditDeductTransaction.omit({ createdAt: true, updatedAt: true }),
-  TextGenerationUsageTransaction.omit({ createdAt: true, updatedAt: true }),
-  ImageGenerationUsageTransaction.omit({ createdAt: true, updatedAt: true }),
-  VideoGenerationUsageTransaction.omit({ createdAt: true, updatedAt: true }),
-  RealtimeVoiceUsageTransaction.omit({ createdAt: true, updatedAt: true }),
-  ImageEditUsageTransaction.omit({ createdAt: true, updatedAt: true }),
-  ToolUsageTransaction.omit({ createdAt: true, updatedAt: true }),
-  CompletionApiUsageTransaction.omit({ createdAt: true, updatedAt: true }),
-  TransferCreditTransaction.omit({ createdAt: true, updatedAt: true })
-]);
-async function subtractCredits(parameters, { db, creditHolderMethods, skipBalanceUpdate, currentCreditHolder }) {
-  const params = secureParameters(parameters, SubtractCreditsSchema);
-  const { ownerId, ownerType, credits, type, description, metadata } = params;
-  let updatedEntity;
-  if (skipBalanceUpdate) {
-    if (!currentCreditHolder) {
-      throw new BadRequestError("currentCreditHolder is required when skipBalanceUpdate is true");
-    }
-    updatedEntity = currentCreditHolder;
-  } else {
-    updatedEntity = await creditHolderMethods.incrementCredits(ownerId, -credits);
-    if (!updatedEntity) {
-      throw new BadRequestError("Failed to update credits");
-    }
-  }
-  if (type === "generic_deduct") {
-    await db.creditTransactions.createTransaction("generic_deduct", {
-      ownerId,
-      ownerType,
-      credits: -Math.abs(credits),
-      // Negative for usage
-      description: description || "Generic credit deduction",
-      metadata,
-      reason: params.reason,
-      // Backward compatibility
-      userId: params.userId
-    });
-  } else if (type === "text_generation_usage") {
-    await db.creditTransactions.createTransaction("text_generation_usage", {
-      ownerId,
-      ownerType,
-      credits: -Math.abs(credits),
-      // Negative for usage
-      description: description || "Text generation usage",
-      metadata,
-      model: params.model,
-      questId: params.questId,
-      sessionId: params.sessionId,
-      inputTokens: params.inputTokens,
-      outputTokens: params.outputTokens
-    });
-  } else if (type === "completion_api_usage") {
-    await db.creditTransactions.createTransaction("completion_api_usage", {
-      ownerId,
-      ownerType,
-      credits: -Math.abs(credits),
-      // Negative for usage
-      description: description || "Completion API usage",
-      metadata,
-      model: params.model,
-      apiKeyId: params.apiKeyId,
-      // Optional - present for API key auth, undefined for JWT
-      inputTokens: params.inputTokens,
-      outputTokens: params.outputTokens
-    });
-  } else if (type === "image_generation_usage") {
-    await db.creditTransactions.createTransaction("image_generation_usage", {
-      ownerId,
-      ownerType,
-      credits: -Math.abs(credits),
-      // Negative for usage
-      description: description || "Image generation usage",
-      metadata,
-      model: params.model,
-      questId: params.questId,
-      sessionId: params.sessionId
-    });
-  } else if (type === "image_edit_usage") {
-    await db.creditTransactions.createTransaction("image_edit_usage", {
-      ownerId,
-      ownerType,
-      credits: -Math.abs(credits),
-      // Negative for usage
-      description: description || "Image editing usage",
-      metadata,
-      model: params.model,
-      questId: params.questId,
-      sessionId: params.sessionId
-    });
-  } else if (type === "video_generation_usage") {
-    await db.creditTransactions.createTransaction("video_generation_usage", {
-      ownerId,
-      ownerType,
-      credits: -Math.abs(credits),
-      // Negative for usage
-      description: description || "Video generation usage",
-      metadata,
-      model: params.model,
-      questId: params.questId,
-      sessionId: params.sessionId
-    });
-  } else if (type === "tool_usage") {
-    await db.creditTransactions.createTransaction("tool_usage", {
-      ownerId,
-      ownerType,
-      credits: -Math.abs(credits),
-      description: description || "Tool usage",
-      metadata,
-      model: params.model,
-      questId: params.questId,
-      sessionId: params.sessionId
-    });
-  } else if (type === "transfer_credit") {
-    await db.creditTransactions.createTransaction("transfer_credit", {
-      ownerId,
-      ownerType,
-      credits: -Math.abs(credits),
-      // Negative for usage
-      description: description || "Transfer credits",
-      recipientId: params.recipientId,
-      recipientType: params.recipientType
-    });
-  } else {
-    await db.creditTransactions.createTransaction("realtime_voice_usage", {
-      ownerId,
-      ownerType,
-      credits: -Math.abs(credits),
-      // Negative for usage
-      description: description || "Voice usage",
-      metadata,
-      model: params.model,
-      sessionId: params.sessionId
-    });
-  }
-  return updatedEntity;
-}
-
-export {
-  SubtractCreditsSchema,
-  subtractCredits
-};

package/dist/chunk-BDQBOLYG.js

@@ -1,120 +0,0 @@
-#!/usr/bin/env node
-
-// ../../b4m-core/packages/services/dist/src/mfaService/utils.js
-import speakeasy from "speakeasy";
-import QRCode from "qrcode";
-var originalEmitWarning = process.emitWarning;
-process.emitWarning = (warning, name) => {
-  if (name === "DeprecationWarning" && warning?.toString().includes("Buffer")) {
-    return;
-  }
-  return originalEmitWarning.call(process, warning, name);
-};
-process.emitWarning = originalEmitWarning;
-async function generateTOTPSetup(userEmail, appName = "Bike4Mind") {
-  const secret = speakeasy.generateSecret({ name: `${appName} (${userEmail})` });
-  const qrCodeUrl = await QRCode.toDataURL(secret.otpauth_url);
-  return {
-    secret: secret.base32,
-    qrCodeUrl,
-    manualEntryKey: secret.base32
-  };
-}
-function verifyTOTPToken(secret, token, window = 1) {
-  return speakeasy.totp.verify({
-    secret,
-    encoding: "base32",
-    token,
-    window
-    // Allow ±30 seconds for clock drift (industry standard)
-  });
-}
-function generateBackupCodes(count = 10) {
-  return Array.from({ length: count }, () => {
-    const secret = speakeasy.generateSecret({ length: 20 });
-    return secret.base32.substring(0, 10).toUpperCase();
-  });
-}
-function verifyBackupCode(userBackupCodes, providedCode) {
-  if (!userBackupCodes || !providedCode) {
-    return { isValid: false };
-  }
-  const cleanProvidedCode = providedCode.trim().toUpperCase();
-  const idx = userBackupCodes.findIndex((code) => {
-    const cleanStoredCode = code.trim().toUpperCase();
-    return cleanStoredCode === cleanProvidedCode;
-  });
-  if (idx !== -1) {
-    return { isValid: true, usedBackupCode: userBackupCodes[idx] };
-  }
-  return { isValid: false };
-}
-function userRequiresMFA(user, enforceMFASetting) {
-  return enforceMFASetting;
-}
-function userHasMFAConfigured(user) {
-  return !!(user.mfa && user.mfa.totpEnabled && user.mfa.totpSecret);
-}
-var MAX_FAILED_ATTEMPTS = 3;
-var LOCKOUT_DURATION_MS = 15 * 60 * 1e3;
-var ATTEMPT_RESET_WINDOW_MS = 60 * 60 * 1e3;
-function isUserLockedOut(user) {
-  if (!user.mfa?.lockedUntil)
-    return false;
-  return /* @__PURE__ */ new Date() < new Date(user.mfa.lockedUntil);
-}
-function getLockoutTimeRemaining(user) {
-  if (!user.mfa?.lockedUntil)
-    return 0;
-  const remaining = new Date(user.mfa.lockedUntil).getTime() - Date.now();
-  return Math.max(0, Math.ceil(remaining / (60 * 1e3)));
-}
-function shouldResetFailedAttempts(user) {
-  if (!user.mfa?.lastFailedAttempt)
-    return false;
-  const timeSinceLastFailure = Date.now() - new Date(user.mfa.lastFailedAttempt).getTime();
-  return timeSinceLastFailure > ATTEMPT_RESET_WINDOW_MS;
-}
-function recordFailedAttempt(user) {
-  const currentAttempts = shouldResetFailedAttempts(user) ? 0 : user.mfa?.failedAttempts || 0;
-  const newAttempts = currentAttempts + 1;
-  const now = /* @__PURE__ */ new Date();
-  const updatedMFA = { ...user.mfa };
-  updatedMFA.failedAttempts = newAttempts;
-  updatedMFA.lastFailedAttempt = now;
-  if (newAttempts >= MAX_FAILED_ATTEMPTS) {
-    updatedMFA.lockedUntil = new Date(Date.now() + LOCKOUT_DURATION_MS);
-  }
-  return updatedMFA;
-}
-function clearFailedAttempts(user) {
-  if (!user.mfa)
-    return null;
-  const updatedMFA = { ...user.mfa };
-  updatedMFA.failedAttempts = 0;
-  updatedMFA.lastFailedAttempt = void 0;
-  updatedMFA.lockedUntil = void 0;
-  return updatedMFA;
-}
-function userEligibleForMFA(user) {
-  return true;
-}
-function userCanDisableMFA(user, enforceMFASetting) {
-  return !enforceMFASetting;
-}
-
-export {
-  generateTOTPSetup,
-  verifyTOTPToken,
-  generateBackupCodes,
-  verifyBackupCode,
-  userRequiresMFA,
-  userHasMFAConfigured,
-  isUserLockedOut,
-  getLockoutTimeRemaining,
-  shouldResetFailedAttempts,
-  recordFailedAttempt,
-  clearFailedAttempts,
-  userEligibleForMFA,
-  userCanDisableMFA
-};