@next-vibe/checker 1.0.11 → 1.0.12

package/src/app/api/[locale]/system/unified-interface/cli/auth/cli-handler.ts

@@ -0,0 +1,95 @@
+import type { ResponseType } from "next-vibe/shared/types/response.schema";
+
+import type { EndpointLogger } from "../../shared/logger/endpoint";
+import {
+  type AuthContext,
+  BaseAuthHandler,
+  type SessionData,
+} from "../../shared/server-only/auth/base-auth-handler";
+import {
+  deleteSessionFile,
+  readSessionFile,
+  writeSessionFile,
+} from "./session-file";
+
+/**
+ * CLI/MCP Authentication Handler
+ * Handles platform-specific storage for CLI/MCP (session files)
+ * All authentication business logic is in AuthRepository
+ */
+export class CliAuthHandler extends BaseAuthHandler {
+  /**
+   * Get authentication token from CLI/MCP storage
+   * Checks: Authorization header → .vibe.session file
+   */
+  async getStoredAuthToken(
+    context: AuthContext,
+    logger: EndpointLogger,
+  ): Promise<string | undefined> {
+    // Check Authorization header first
+    if (context.request) {
+      const authHeader = context.request.headers.get("authorization");
+      if (authHeader?.startsWith("Bearer ")) {
+        const token = authHeader.slice(7); // Remove "Bearer " prefix
+        logger.debug("Found auth token in Authorization header");
+        return token;
+      }
+    }
+
+    // Fall back to session file
+    const sessionResult = await readSessionFile(logger);
+    if (sessionResult.success) {
+      logger.debug("Found auth token in session file");
+      return sessionResult.data.token;
+    }
+
+    return undefined;
+  }
+
+  /**
+   * Store authentication token in .vibe.session file
+   * @param rememberMe - If true, session lasts 30 days; if false, 7 days
+   */
+  async storeAuthToken(
+    token: string,
+    userId: string,
+    leadId: string,
+    logger: EndpointLogger,
+    rememberMe = true, // Default to true (30 days)
+  ): Promise<ResponseType<void>> {
+    // Set session duration based on rememberMe flag
+    // Remember me: 30 days, Regular session: 7 days
+    const sessionDurationDays = rememberMe ? 30 : 7;
+    const sessionDurationSeconds = sessionDurationDays * 24 * 60 * 60;
+
+    const expiresAt = new Date(Date.now() + sessionDurationSeconds * 1000);
+
+    const sessionData: SessionData = {
+      token,
+      userId,
+      leadId,
+      expiresAt: expiresAt.toISOString(),
+      createdAt: new Date().toISOString(),
+    };
+
+    logger.debug("Storing CLI session", {
+      userId,
+      leadId,
+      rememberMe,
+      sessionType: rememberMe ? "persistent (30 days)" : "regular (7 days)",
+    });
+    return await writeSessionFile(sessionData, logger);
+  }
+
+  /**
+   * Clear authentication token by deleting .vibe.session file
+   */
+  async clearAuthToken(logger: EndpointLogger): Promise<ResponseType<void>> {
+    return await deleteSessionFile(logger);
+  }
+}
+
+/**
+ * Singleton instance
+ */
+export const cliAuthHandler = new CliAuthHandler();

package/src/app/api/[locale]/system/unified-interface/cli/auth/cli-user.ts

@@ -0,0 +1,146 @@
+/**
+ * CLI User Factory
+ * Consolidated CLI user creation logic
+ * Eliminates 5+ duplicate implementations across the codebase
+ */
+
+import type { ResponseType } from "next-vibe/shared/types/response.schema";
+import { ErrorResponseTypes } from "next-vibe/shared/types/response.schema";
+
+import type { InferJwtPayloadTypeFromRoles } from "@/app/api/[locale]/system/unified-interface/shared/endpoints/route/handler";
+import type { EndpointLogger } from "@/app/api/[locale]/system/unified-interface/shared/logger/endpoint";
+import {
+  UserPermissionRole,
+  type UserRoleValue,
+} from "@/app/api/[locale]/user/user-roles/enum";
+import type { CountryLanguage } from "@/i18n/core/config";
+
+import { cliEnv } from "../env";
+
+/**
+ * Default CLI user configuration
+ */
+const DEFAULT_CLI_USER_ID = "00000000-0000-0000-0000-000000000001";
+
+/**
+ * Get CLI user email from environment
+ * Returns null if VIBE_CLI_USER_EMAIL is not set
+ */
+export function getCliUserEmail(): string | null {
+  return cliEnv.VIBE_CLI_USER_EMAIL ?? null;
+}
+
+/**
+ * Create a default CLI user payload for auth bypass scenarios
+ * Used for commands that don't require authenticated user (e.g., seed, dev)
+ */
+export function createDefaultCliUser(): InferJwtPayloadTypeFromRoles<
+  readonly UserRoleValue[]
+> {
+  return {
+    isPublic: false,
+    id: DEFAULT_CLI_USER_ID,
+    leadId: DEFAULT_CLI_USER_ID,
+  } as InferJwtPayloadTypeFromRoles<readonly UserRoleValue[]>;
+}
+
+/**
+ * Create a public CLI user payload
+ * Used when VIBE_CLI_USER_EMAIL is not configured
+ */
+export function createPublicCliUser(): InferJwtPayloadTypeFromRoles<
+  readonly UserRoleValue[]
+> {
+  return {
+    isPublic: true,
+    leadId: DEFAULT_CLI_USER_ID,
+  } as InferJwtPayloadTypeFromRoles<readonly UserRoleValue[]>;
+}
+/**
+ * Create a mock user for testing/development
+ * Used in tasks, generators, and other system operations
+ */
+export function createMockUser(): {
+  id: string;
+  leadId: string;
+  isPublic: false;
+  roles: (typeof UserPermissionRole.ADMIN)[];
+} {
+  return {
+    id: DEFAULT_CLI_USER_ID,
+    leadId: DEFAULT_CLI_USER_ID,
+    isPublic: false,
+    roles: [UserPermissionRole.ADMIN],
+  };
+}
+
+/**
+ * Get CLI user with proper authentication flow:
+ * 1. Check for session user (from .vibe.session file)
+ * 2. Check VIBE_CLI_USER_EMAIL from .env and authenticate from DB
+ * 3. If VIBE_CLI_USER_EMAIL is empty → return public user
+ * 4. If email is set but not found in DB → return error
+ *
+ * @param logger - Logger instance for debugging
+ * @param locale - Locale for database queries
+ * @returns ResponseType with CLI user payload or error
+ */
+export async function getCliUser(
+  logger: EndpointLogger,
+  locale: CountryLanguage,
+): Promise<
+  ResponseType<InferJwtPayloadTypeFromRoles<readonly UserRoleValue[]>>
+> {
+  // Enhanced debugging: Log authentication flow entry point
+  const authFlowData = {
+    locale,
+    cwd: process.cwd(),
+    nodeEnv: process.env.NODE_ENV,
+    vibeProjectRoot: process.env.VIBE_PROJECT_ROOT,
+  };
+  logger.debug(
+    "[CLI AUTH] Starting CLI user authentication flow",
+    authFlowData,
+  );
+
+  // Step 1: Session verification removed - AuthRepository deleted
+
+  // Step 2: Check VIBE_CLI_USER_EMAIL environment variable
+  logger.debug(
+    "[CLI AUTH] Step 2: Checking VIBE_CLI_USER_EMAIL environment variable",
+  );
+  const cliUserEmail = getCliUserEmail();
+
+  logger.debug("[CLI AUTH] VIBE_CLI_USER_EMAIL result", {
+    hasEmail: !!cliUserEmail,
+    email: cliUserEmail ? `${cliUserEmail.slice(0, 3)}***` : null,
+    envVarExists: "VIBE_CLI_USER_EMAIL" in process.env,
+  });
+
+  // Step 3: If VIBE_CLI_USER_EMAIL is not set, return public user
+  if (!cliUserEmail) {
+    logger.debug(
+      "[CLI AUTH] Step 3: CLI user email not configured, creating public user",
+      {
+        envVar: "VIBE_CLI_USER_EMAIL",
+      },
+    );
+
+    // Minimal checker package: use default ID without lead creation
+    logger.debug("Using default CLI user (minimal checker package)");
+    return {
+      success: true,
+      data: {
+        isPublic: true,
+        leadId: DEFAULT_CLI_USER_ID,
+      } as InferJwtPayloadTypeFromRoles<readonly UserRoleValue[]>,
+    };
+  }
+
+  // Step 4: Email authentication removed - AuthRepository deleted
+  return {
+    success: false,
+    message: "app.api.system.unifiedInterface.cli.auth.errors.authNotAvailable",
+    errorType: ErrorResponseTypes.UNAUTHORIZED,
+  };
+}

package/src/app/api/[locale]/system/unified-interface/cli/auth/session-file.ts

@@ -0,0 +1,266 @@
+import { promises as fs } from "node:fs";
+import { join } from "node:path";
+
+import type { ResponseType } from "next-vibe/shared/types/response.schema";
+import {
+  ErrorResponseTypes,
+  fail,
+  success,
+} from "next-vibe/shared/types/response.schema";
+import { parseError } from "next-vibe/shared/utils";
+
+import type { EndpointLogger } from "../../shared/logger/endpoint";
+import type { SessionData } from "../../shared/server-only/auth/base-auth-handler";
+
+/**
+ * Session file path
+ * Stored in project root directory
+ */
+const SESSION_FILE_NAME = ".vibe.session";
+
+/**
+ * Get project root directory
+ * This is more reliable than process.cwd() which depends on where the process was started
+ */
+function getProjectRoot(): string {
+  // Try environment variable first (can be set by CLI or MCP config)
+  if (process.env.VIBE_PROJECT_ROOT) {
+    return process.env.VIBE_PROJECT_ROOT;
+  }
+
+  // Fall back to process.cwd() - this will work when MCP server runs from project root
+  return process.cwd();
+}
+
+/**
+ * Error message patterns for file not found errors
+ */
+const FILE_NOT_FOUND_ERROR_PATTERNS = {
+  ENOENT: "ENOENT",
+  NO_SUCH_FILE: "no such file",
+} as const;
+
+/**
+ * Get session file path
+ * Uses project root from environment variable or falls back to cwd
+ */
+function getSessionFilePath(): string {
+  const projectRoot = getProjectRoot();
+  const sessionPath = join(projectRoot, SESSION_FILE_NAME);
+
+  return sessionPath;
+}
+
+/**
+ * Read session data from .vibe.session file
+ */
+export async function readSessionFile(
+  logger: EndpointLogger,
+): Promise<ResponseType<SessionData>> {
+  try {
+    const sessionPath = getSessionFilePath();
+    const projectRoot = getProjectRoot();
+    const cwd = process.cwd();
+
+    // Enhanced debugging: Log current working directory and full path
+    logger.debug("Reading session file", {
+      path: sessionPath,
+      projectRoot,
+      cwd,
+      sessionFileName: SESSION_FILE_NAME,
+      vibeProjectRoot: process.env.VIBE_PROJECT_ROOT,
+    });
+
+    // Check if file exists before attempting to read
+    try {
+      await fs.access(sessionPath);
+      logger.debug("Session file exists at path", { path: sessionPath });
+    } catch (accessError) {
+      const errorMsg = parseError(accessError).message;
+      logger.debug("Session file does not exist at path", {
+        path: sessionPath,
+        accessError: errorMsg,
+      });
+    }
+
+    const fileContent = await fs.readFile(sessionPath, "utf-8");
+    const sessionData = JSON.parse(fileContent) as SessionData;
+
+    // Validate session data structure
+    if (
+      !sessionData.token ||
+      !sessionData.userId ||
+      !sessionData.leadId ||
+      !sessionData.expiresAt
+    ) {
+      return fail({
+        message:
+          "app.api.system.unifiedInterface.cli.vibe.errors.invalidFormat",
+        errorType: ErrorResponseTypes.VALIDATION_ERROR,
+        messageParams: { path: sessionPath },
+      });
+    }
+
+    // Check if session is expired
+    const expiresAt = new Date(sessionData.expiresAt);
+    if (expiresAt < new Date()) {
+      logger.debug("Session expired", { expiresAt: sessionData.expiresAt });
+      return fail({
+        message:
+          "app.api.system.unifiedInterface.cli.vibe.errors.sessionExpired",
+        errorType: ErrorResponseTypes.UNAUTHORIZED,
+        messageParams: { expiresAt: sessionData.expiresAt },
+      });
+    }
+
+    logger.debug("Session file read successfully", {
+      userId: sessionData.userId,
+      expiresAt: sessionData.expiresAt,
+    });
+
+    return success(sessionData);
+  } catch (error) {
+    const parsedError = parseError(error);
+
+    // File not found is not an error - user is not authenticated
+    const isFileNotFoundError =
+      parsedError.message.includes(FILE_NOT_FOUND_ERROR_PATTERNS.ENOENT) ||
+      parsedError.message.includes(FILE_NOT_FOUND_ERROR_PATTERNS.NO_SUCH_FILE);
+    if (isFileNotFoundError) {
+      // Enhanced debugging: Log path details when file not found
+      const debugData = {
+        searchedPath: getSessionFilePath(),
+        projectRoot: getProjectRoot(),
+        cwd: process.cwd(),
+        vibeProjectRoot: process.env.VIBE_PROJECT_ROOT,
+        errorMessage: parsedError.message,
+      };
+      logger.debug(
+        "Session file not found - user not authenticated",
+        debugData,
+      );
+      return fail({
+        message: "app.api.system.unifiedInterface.cli.vibe.errors.notFound",
+        errorType: ErrorResponseTypes.NOT_FOUND,
+      });
+    }
+
+    logger.error("Error reading session file", {
+      ...parsedError,
+      path: getSessionFilePath(),
+      projectRoot: getProjectRoot(),
+      cwd: process.cwd(),
+      vibeProjectRoot: process.env.VIBE_PROJECT_ROOT,
+    });
+    return fail({
+      message: "app.api.system.unifiedInterface.cli.vibe.errors.readFailed",
+      errorType: ErrorResponseTypes.INTERNAL_ERROR,
+      messageParams: { error: parsedError.message },
+    });
+  }
+}
+
+/**
+ * Write session data to .vibe.session file
+ */
+export async function writeSessionFile(
+  sessionData: SessionData,
+  logger: EndpointLogger,
+): Promise<ResponseType<void>> {
+  try {
+    const sessionPath = getSessionFilePath();
+    logger.debug("Writing session file", {
+      path: sessionPath,
+      userId: sessionData.userId,
+    });
+
+    // Validate session data
+    if (
+      !sessionData.token ||
+      !sessionData.userId ||
+      !sessionData.leadId ||
+      !sessionData.expiresAt
+    ) {
+      return fail({
+        message: "app.api.system.unifiedInterface.cli.vibe.errors.invalidData",
+        errorType: ErrorResponseTypes.VALIDATION_ERROR,
+      });
+    }
+
+    const fileContent = JSON.stringify(sessionData, null, 2);
+    await fs.writeFile(sessionPath, fileContent, "utf-8");
+
+    logger.debug("Session file written successfully", {
+      path: sessionPath,
+      userId: sessionData.userId,
+    });
+
+    return success();
+  } catch (error) {
+    const parsedError = parseError(error);
+    logger.error("Error writing session file", parsedError);
+    return fail({
+      message: "app.api.system.unifiedInterface.cli.vibe.errors.writeFailed",
+      errorType: ErrorResponseTypes.INTERNAL_ERROR,
+      messageParams: { error: parsedError.message },
+    });
+  }
+}
+
+/**
+ * Delete session file
+ */
+export async function deleteSessionFile(
+  logger: EndpointLogger,
+): Promise<ResponseType<void>> {
+  try {
+    const sessionPath = getSessionFilePath();
+    logger.debug("Deleting session file", { path: sessionPath });
+
+    await fs.unlink(sessionPath);
+
+    logger.debug("Session file deleted successfully", { path: sessionPath });
+    return success();
+  } catch (error) {
+    const parsedError = parseError(error);
+
+    // File not found is not an error - already logged out
+    const isFileNotFoundError =
+      parsedError.message.includes(FILE_NOT_FOUND_ERROR_PATTERNS.ENOENT) ||
+      parsedError.message.includes(FILE_NOT_FOUND_ERROR_PATTERNS.NO_SUCH_FILE);
+    if (isFileNotFoundError) {
+      logger.debug("Session file not found - already logged out");
+      return success();
+    }
+
+    logger.error("Error deleting session file", parsedError);
+    return fail({
+      message: "app.api.system.unifiedInterface.cli.vibe.errors.deleteFailed",
+      errorType: ErrorResponseTypes.INTERNAL_ERROR,
+      messageParams: { error: parsedError.message },
+    });
+  }
+}
+
+/**
+ * Check if session file exists
+ */
+export async function sessionFileExists(
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  logger: EndpointLogger,
+): Promise<boolean> {
+  try {
+    const sessionPath = getSessionFilePath();
+    await fs.access(sessionPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get session file path for display purposes
+ */
+export function getSessionFilePathForDisplay(): string {
+  return getSessionFilePath();
+}

package/src/app/api/[locale]/system/unified-interface/cli/env.ts

@@ -0,0 +1,26 @@
+/**
+ * CLI Environment Configuration
+ */
+
+import "server-only";
+
+import { z } from "zod";
+
+import { defineEnv } from "@/app/api/[locale]/system/unified-interface/shared/env/define-env";
+import type { CountryLanguage } from "@/i18n/core/config";
+import { defaultLocale } from "@/i18n/core/config";
+
+export const { env: cliEnv } = defineEnv({
+  VIBE_CLI_USER_EMAIL: {
+    schema: z.string().email().optional(),
+    example: "admin@example.com",
+    comment: "CLI user email",
+  },
+  VIBE_CLI_LOCALE: {
+    schema: (z.string() as z.Schema<CountryLanguage>)
+      .optional()
+      .default(defaultLocale),
+    example: "en-GLOBAL",
+    comment: "CLI locale setting",
+  },
+});

package/src/app/api/[locale]/system/unified-interface/cli/i18n/de/index.ts

@@ -0,0 +1,157 @@
+import { translations as setupTranslations } from "../../setup/i18n/de";
+import type { translations as enTranslations } from "../en";
+
+export const translations: typeof enTranslations = {
+  setup: setupTranslations,
+  auth: {
+    errors: {
+      userNotFound:
+        "CLI-Benutzer mit E-Mail {{email}} wurde nicht in der Datenbank gefunden. Bitte führen Sie zuerst 'vibe seed' aus.",
+      databaseError:
+        "Datenbankfehler beim Abrufen des CLI-Benutzers: {{error}}",
+      authNotAvailable: "Authentifizierung ist nicht verfügbar",
+    },
+  },
+  vibe: {
+    startingUp: "Vibe CLI wird gestartet...",
+    executeCommand: "Befehl wird ausgeführt",
+    executing: "Wird ausgeführt",
+    listCommands: "Alle verfügbaren Befehle auflisten",
+    output: "Ausgabeformat",
+    utils: {
+      debug: {
+        executionSummary:
+          "Ausführung: {{executionSeconds}}s | Overhead: {{overheadSeconds}}s | Gesamt: {{totalSeconds}}s",
+      },
+    },
+    help: {
+      title: "Vibe CLI Hilfe",
+      description: "Vibe CLI - API-Ausführungstool der nächsten Generation",
+      usage: "Verwendung: vibe <befehl> [optionen]",
+      commands: "Verfügbare Befehle",
+      options: "Optionen",
+      examples: "Beispiele",
+      userType: "Benutzertyp angeben (admin, public, etc.)",
+      locale: "Sprache angeben (en-GLOBAL, de-DE, pl-PL)",
+      verbose: "Ausführliche Ausgabe aktivieren",
+      dryRun: "Testlauf ohne Ausführung durchführen",
+      interactive: "Interaktiven Modus aktivieren",
+    },
+    errors: {
+      routeNotFound: "Route nicht gefunden",
+      executionFailed: "Ausführung fehlgeschlagen",
+      unknownError: "Unbekannter Fehler aufgetreten",
+      publicPayloadNotSupported: "Öffentliche Nutzlast nicht unterstützt",
+      invalidTokenPayload: "Ungültige Token-Nutzlast",
+      invalidToken: "Ungültiges Token",
+      signingFailed: "Token-Signierung fehlgeschlagen",
+      userNotFound: "Benutzer nicht gefunden",
+      authenticationFailed: "Authentifizierung fehlgeschlagen",
+      invalidFormat: "Ungültiges Sitzungsformat",
+      sessionExpired: "Sitzung abgelaufen",
+      notFound: "Sitzung nicht gefunden",
+      readFailed: "Sitzung konnte nicht gelesen werden",
+      invalidData: "Ungültige Sitzungsdaten",
+      writeFailed: "Sitzung konnte nicht geschrieben werden",
+      deleteFailed: "Sitzung konnte nicht gelöscht werden",
+      storeFailed: "Sitzung konnte nicht gespeichert werden",
+      clearFailed: "Sitzung konnte nicht gelöscht werden",
+      setLeadIdCookieFailed: "Lead-ID-Cookie konnte nicht gesetzt werden",
+    },
+    endpoints: {
+      endpointHandler: {
+        error: {
+          form_validation_failed: "Formularvalidierung fehlgeschlagen",
+          unauthorized: "Nicht autorisierter Zugriff",
+          errors: {
+            unknown_validation_error: "Unbekannter Validierungsfehler",
+            invalid_request_data: "Ungültige Anfragedaten",
+            invalid_url_parameters: "Ungültige URL-Parameter",
+          },
+          general: {
+            internal_server_error: "Interner Serverfehler",
+          },
+        },
+      },
+      renderers: {
+        cliUi: {
+          helpHandler: {
+            noDescription: "Keine Beschreibung verfügbar",
+            flagDataDesc: "Anfragedaten als JSON bereitstellen",
+            flagUserTypeDesc: "Benutzertyp angeben (admin, customer, public)",
+            flagLocaleDesc: "Locale angeben (en-GLOBAL, de-DE, pl-PL)",
+            flagOutputDesc: "Ausgabeformat (pretty, json)",
+            flagVerboseDesc: "Ausführliche Ausgabe aktivieren",
+            flagDryRunDesc: "Testlauf ohne Ausführung durchführen",
+            usageLabel: "Verwendung",
+            availableCommandsLabel: "Verfügbare Befehle",
+            globalOptionsLabel: "Globale Optionen",
+            examplesLabel: "Beispiele",
+          },
+          widgets: {
+            common: {
+              noDataAvailable: "Keine Daten verfügbar",
+              noIssuesFound: "Keine Probleme gefunden",
+              invalidDataFormat: "Ungültiges Datenformat",
+              info: "Info",
+              items: "Elemente",
+              andMoreItems: "und {count} weitere Elemente",
+              affectedFiles: "Betroffene Dateien",
+              summary: "Zusammenfassung",
+              files: "Dateien",
+              issues: "Probleme",
+              other: "Andere",
+              error: "Fehler",
+              errors: "Fehler",
+              warning: "Warnung",
+              warnings: "Warnungen",
+            },
+          },
+        },
+      },
+    },
+    interactive: {
+      welcome: "Willkommen im Vibe Interaktiven Modus",
+      goodbye: "Auf Wiedersehen!",
+      navigation: {
+        rootName: "Wurzel",
+        directoryIcon: "📁",
+        upIcon: "⬆️",
+        goUp: "Nach oben",
+        routeIcon: "🔗",
+        routes: "Routen",
+        settingsIcon: "⚙️",
+        settings: "Einstellungen",
+        exitIcon: "🚪",
+        exit: "Beenden",
+        navigate: "Navigieren",
+        route: "Route",
+        method: "Methode",
+        description: "Beschreibung",
+        noDefinition: "Keine Definition gefunden",
+        executionFailed: "Ausführung fehlgeschlagen",
+        executeAnother: "Weitere ausführen",
+        selectLocale: "Sprache wählen",
+        englishGlobal: "Englisch (Global)",
+        requestData: "Anfragedaten",
+        urlParameters: "URL-Parameter",
+        preview: "Vorschau",
+        executeWithParams: "Mit Parametern ausführen",
+        navigationError: "Navigationsfehler",
+        chooseSettingToModify: "Einstellung zum Ändern wählen",
+        outputFormatCurrent: "Ausgabeformat (aktuell",
+        verboseModeCurrent: "Ausführlicher Modus (aktuell",
+        localeCurrent: "Sprache (aktuell",
+        backToMainMenu: "Zurück zum Hauptmenü",
+        chooseOutputFormat: "Ausgabeformat wählen",
+        prettyFormatted: "Hübsch formatiert",
+        jsonRaw: "JSON (Roh)",
+        enableVerboseOutput: "Ausführliche Ausgabe aktivieren",
+        chooseLocale: "Sprache wählen",
+        german: "Deutsch",
+        polish: "Polnisch",
+        settingUpdated: "Einstellung erfolgreich aktualisiert",
+      },
+    },
+  },
+};