feat: add web upload for EML/MBOX files #260

web/src/api/import/api.ts

@@ -0,0 +1,82 @@
+//
+// Copyright (c) 2025-2026 rustmailer.com (https://rustmailer.com)
+//
+// This file is part of the Bichon Email Archiving Project
+
+import axiosInstance from '@/api/axiosInstance';
+import { list_accounts } from '@/api/account/api';
+import type { AccountModel } from '@/api/account/api';
+
+export interface ImportProgress {
+  import_id: string;
+  status: 'Pending' | 'Processing' | 'Completed' | 'Failed';
+  format: string;
+  total: number;
+  success: number;
+  duplicates: number;
+  failed: number;
+  failed_details: { index: number; error_message: string }[];
+}
+
+export const upload_import = async (
+  accountId: number,
+  mailFolder: string,
+  fileName: string,
+  file: File,
+  onProgress?: (pct: number) => void
+): Promise<ImportProgress> => {
+  const response = await axiosInstance.post<ImportProgress>(
+    `api/v1/upload-import`,
+    file,
+    {
+      params: { account_id: accountId, mail_folder: mailFolder, file_name: fileName },
+      headers: { 'Content-Type': 'application/octet-stream' },
+      onUploadProgress: (e) => {
+        if (e.total && onProgress) onProgress(Math.round((e.loaded / e.total) * 100));
+      },
+    }
+  );
+  return response.data;
+};
+
+export const get_import_progress = async (importId: string): Promise<ImportProgress> => {
+  const response = await axiosInstance.get<ImportProgress>(
+    `api/v1/import-progress/${importId}`
+  );
+  return response.data;
+};
+
+export const check_disk_space = async (): Promise<number> => {
+  const response = await axiosInstance.get<number>('api/v1/check-disk-space');
+  return response.data;
+};
+
+export const get_nosync_accounts = async (): Promise<AccountModel[]> => {
+  const data = await list_accounts();
+  return (data.items || []).filter(
+    (a) => a.account_type === 'NoSync' && a.enabled
+  );
+};
+
+// ── Import history ────────────────────────────────────────────────
+
+export interface ImportHistory {
+  id: string;
+  user_id: number;
+  import_id: string;
+  account_id: number;
+  folder: string;
+  format: string;
+  status: 'pending' | 'processing' | 'completed' | 'failed';
+  total: number;
+  success: number;
+  duplicates: number;
+  failed: number;
+  failed_details: { index: number; error_message: string }[];
+  created_at: number;
+}
+
+export const list_import_history = async (): Promise<ImportHistory[]> => {
+  const response = await axiosInstance.get<ImportHistory[]>('api/v1/import-history');
+  return response.data;
+};

web/src/components/layout/data/sidebar-data.ts

@@ -22,7 +22,7 @@ import {
   IconLayoutDashboard,
   IconSettings
 } from '@tabler/icons-react'
-import { IdCard, Inbox, Paperclip, Search, Users2 } from 'lucide-react'
+import { IdCard, Inbox, Paperclip, Search, Upload, Users2 } from 'lucide-react'
 import { type SidebarData } from '../types'
 import { useTranslation } from 'react-i18next'
 import { useCurrentUser } from '@/hooks/use-current-user'
@@ -57,6 +57,12 @@ export function useSidebarData(): SidebarData {
             url: '/search',
             icon: Search,
           },
+          {
+            title: t('import.title', 'Import'),
+            url: '/import',
+            icon: Upload,
+            visible: require_any_permission(['data:import:batch']),
+          },
           {
             title: t('navigation.attachment'),
             url: '/attachment',

web/src/features/import/folder-hint.ts

@@ -0,0 +1,146 @@
+//
+// Copyright (c) 2025-2026 rustmailer.com (https://rustmailer.com)
+//
+// This file is part of the Bichon Email Archiving Project
+
+/**
+ * Parse raw EML/MBOX headers from the first few KB of a file and return a
+ * suggested folder name, or null if nothing useful was found.
+ *
+ * Mirrors the CLI logic in crates/cli/src/mbox/gmail.rs (determine_folder).
+ */
+
+const HEADER_READ_BYTES = 64 * 1024; // read first 64 KB to get headers
+
+/** RFC 2047 encoded-word prefix. We do a best-effort decode. */
+function decodeRfc2047(raw: string): string {
+  return raw.replace(/=\?[^?]+\?[BbQq]\?[^?]*\?=/gi, (match) => {
+    try {
+      const parts = match.split('?');
+      const charset = parts[1];
+      const encoding = parts[2].toUpperCase();
+      const encoded = parts[3];
+      let bytes: Uint8Array;
+      if (encoding === 'B') {
+        const bin = atob(encoded);
+        bytes = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; i++) bytes[i] = bin.charCodeAt(i);
+      } else {
+        // Q-encoding
+        const hex = encoded.replace(/_/g, ' ').replace(/=([0-9A-Fa-f]{2})/g, (_, h) =>
+          String.fromCharCode(parseInt(h, 16)),
+        );
+        bytes = new TextEncoder().encode(hex);
+      }
+      return new TextDecoder(charset).decode(bytes);
+    } catch {
+      return match;
+    }
+  });
+}
+
+/** Extract a single header value from raw email text. Case-insensitive. */
+function getHeader(raw: string, name: string): string | null {
+  const re = new RegExp(`^${name.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*:\\s*(.+)$`, 'im');
+  const m = raw.match(re);
+  if (!m) return null;
+  // Unfold continuation lines (leading whitespace)
+  let val = m[1].trim();
+  const startIdx = m.index! + m[0].length;
+  const rest = raw.slice(startIdx);
+  const contRe = /^\s+(.+)$/gm;
+  let cm: RegExpExecArray | null;
+  while ((cm = contRe.exec(rest)) !== null) {
+    val += ' ' + cm[1].trim();
+  }
+  return decodeRfc2047(val);
+}
+
+/** Determine folder from X-Gmail-Labels, mirroring the CLI's determine_folder(). */
+function folderFromGmailLabels(raw: string): string | null {
+  const labelsRaw = getHeader(raw, 'X-Gmail-Labels');
+  if (!labelsRaw) return null;
+
+  const statusBlacklist = new Set(['Opened', 'Unread', 'Archived']);
+  const allLabels = labelsRaw.split(',').map((s) => s.trim()).filter(Boolean);
+  if (allLabels.length === 0) return null;
+
+  const filtered = allLabels.filter((l) => !statusBlacklist.has(l));
+  if (filtered.length === 0) return allLabels[0];
+  if (filtered.length === 1) return filtered[0];
+
+  // Prefer business labels over generic Inbox/Sent
+  const business = filtered.find((l) => l !== 'Inbox' && l !== 'Sent');
+  return business ?? filtered[0];
+}
+
+/** Try to read mailbox_name from X-Bichon-Metadata JSON header. */
+function folderFromBichonMetadata(raw: string): string | null {
+  const metaRaw = getHeader(raw, 'X-Bichon-Metadata');
+  if (!metaRaw) return null;
+  try {
+    const meta = JSON.parse(metaRaw);
+    if (meta?.mailbox_name && typeof meta.mailbox_name === 'string') {
+      return meta.mailbox_name;
+    }
+  } catch {
+    // ignore parse errors
+  }
+  return null;
+}
+
+/** Derive a folder from the file name (e.g. "Inbox.mbox" → "Inbox"). */
+function folderFromFileName(fileName: string): string | null {
+  const base = fileName.replace(/\.[^.]+$/, ''); // strip extension
+  if (!base || base === fileName) return null;
+  // Common patterns
+  if (/^[a-zA-Z0-9_/\-.\s]+$/.test(base) && base.length > 0 && base.length < 128) {
+    return base;
+  }
+  return null;
+}
+
+export interface FolderHint {
+  /** The suggested folder name. */
+  name: string;
+  /** Where the hint came from. */
+  source: 'gmail-labels' | 'bichon-metadata' | 'filename' | 'mbox-filename';
+}
+
+/**
+ * Read the first chunk of a File and return folder hints extracted from headers.
+ * Returns null if no hint could be extracted.
+ */
+export async function extractFolderHint(file: File): Promise<FolderHint | null> {
+  const ext = file.name.split('.').pop()?.toLowerCase();
+  const isMbox = ext === 'mbox';
+
+  // Read first 64 KB — enough for headers of the first message
+  const chunk = new Uint8Array(await file.slice(0, HEADER_READ_BYTES).arrayBuffer());
+  const raw = new TextDecoder('utf-8', { fatal: false }).decode(chunk);
+
+  // MBOX: the first line is "From ...", headers start after the first newline
+  const headers = isMbox
+    ? raw.replace(/^From [^\n]*\n/, '') // strip MBOX "From " separator
+    : raw;
+
+  // 1. X-Bichon-Metadata (highest priority, explicit)
+  const bichonFolder = folderFromBichonMetadata(headers);
+  if (bichonFolder) return { name: bichonFolder, source: 'bichon-metadata' };
+
+  // 2. X-Gmail-Labels
+  const gmailFolder = folderFromGmailLabels(headers);
+  if (gmailFolder) return { name: gmailFolder, source: 'gmail-labels' };
+
+  // 3. For MBOX files, use the filename
+  if (isMbox) {
+    const fnFolder = folderFromFileName(file.name);
+    if (fnFolder) return { name: fnFolder, source: 'mbox-filename' };
+  }
+
+  // 4. For EML files, try the filename
+  const fnFolder = folderFromFileName(file.name);
+  if (fnFolder) return { name: fnFolder, source: 'filename' };
+
+  return null;
+}

web/src/features/import/index.tsx

@@ -0,0 +1,819 @@
+//
+// Copyright (c) 2025-2026 rustmailer.com (https://rustmailer.com)
+//
+// This file is part of the Bichon Email Archiving Project
+
+import { useState, useRef, useCallback, useEffect } from 'react';
+import { useTranslation } from 'react-i18next';
+import { useMutation, useQuery } from '@tanstack/react-query';
+import {
+  Upload, FileText, X, CheckCircle2, AlertTriangle,
+  Sparkles, PenLine, ListTree, ChevronsUpDown, Check,
+  Clock, ChevronRight,
+} from 'lucide-react';
+
+import { Button } from '@/components/ui/button';
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Progress } from '@/components/ui/progress';
+import { ScrollArea } from '@/components/ui/scroll-area';
+import { RadioGroup, RadioGroupItem } from '@/components/ui/radio-group';
+import { cn } from '@/lib/utils';
+import { Main } from '@/components/layout/main';
+import { FixedHeader } from '@/components/layout/fixed-header';
+import { useToast } from '@/hooks/use-toast';
+import { Badge } from '@/components/ui/badge';
+import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
+import {
+  Command,
+  CommandEmpty,
+  CommandGroup,
+  CommandInput,
+  CommandItem,
+  CommandList,
+} from '@/components/ui/command';
+
+import {
+  upload_import,
+  get_import_progress,
+  get_nosync_accounts,
+  list_import_history,
+  type ImportProgress,
+  type ImportHistory,
+} from '@/api/import/api';
+import { list_mailboxes } from '@/api/mailbox/api';
+import { extractFolderHint, type FolderHint } from './folder-hint';
+
+const MAX_EML = 100 * 1024 * 1024;   // 100 MB
+const MAX_MBOX = 1024 * 1024 * 1024; // 1 GB
+
+// MIME types that are clearly NOT email files — reject these upfront.
+const BLOCKED_MIME_PREFIXES = [
+  'video/', 'audio/', 'image/', 'font/',
+  'application/zip', 'application/gzip', 'application/x-tar',
+  'application/x-7z', 'application/x-rar',
+  'application/vnd.', 'application/pdf',
+  'application/x-msdownload', 'application/x-executable',
+];
+
+function isValidFileType(file: File, ext: string): boolean {
+  // Check MIME type: reject known binary types
+  const mime = file.type.toLowerCase();
+  if (mime) {
+    for (const prefix of BLOCKED_MIME_PREFIXES) {
+      if (mime.startsWith(prefix)) return false;
+    }
+  }
+  // Check extension
+  return ext === 'eml' || ext === 'mbox';
+}
+
+type FolderMode = 'header' | 'existing' | 'custom';
+
+interface QueuedFile {
+  file: File;
+  sizeOk: boolean;
+  typeOk: boolean;
+}
+
+function formatSize(bytes: number) {
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)} GB`;
+}
+
+function folderHintLabel(hint: FolderHint): string {
+  switch (hint.source) {
+    case 'gmail-labels': return 'X-Gmail-Labels';
+    case 'bichon-metadata': return 'X-Bichon-Metadata';
+    case 'filename': return 'filename';
+    case 'mbox-filename': return 'mbox filename';
+  }
+}
+
+export default function ImportPage() {
+  const { t } = useTranslation();
+  const { toast } = useToast();
+
+  const [accountId, setAccountId] = useState<string>('');
+  const [folderMode, setFolderMode] = useState<FolderMode>('header');
+  const [folder, setFolder] = useState('INBOX');
+  const [files, setFiles] = useState<QueuedFile[]>([]);
+  const [dragging, setDragging] = useState(false);
+  // const [importId, setImportId] = useState<string | null>(null);
+  const [progress, setProgress] = useState<ImportProgress | null>(null);
+  const [uploadPct, setUploadPct] = useState(0);
+  const [phase, setPhase] = useState<'idle' | 'uploading' | 'processing' | 'done'>('idle');
+  const [folderHint, setFolderHint] = useState<FolderHint | null>(null);
+  const [headerFolder, setHeaderFolder] = useState('INBOX');
+
+  // Combobox state for existing mailbox selection
+  const [mailboxOpen, setMailboxOpen] = useState(false);
+  // Combobox state for account selection
+  const [accountOpen, setAccountOpen] = useState(false);
+
+  const pollRef = useRef<ReturnType<typeof setInterval> | null>(null);
+
+  const { data: accounts = [] } = useQuery({
+    queryKey: ['nosync-accounts'],
+    queryFn: get_nosync_accounts,
+    staleTime: 30_000,
+  });
+
+  const { data: mailboxData } = useQuery({
+    queryKey: ['account-mailboxes', accountId],
+    queryFn: () => list_mailboxes(Number(accountId), false),
+    enabled: !!accountId,
+    staleTime: 60_000,
+  });
+  const mailboxes = mailboxData?.mailboxes ?? [];
+
+  // Import history
+  const { data: history = [], refetch: refetchHistory } = useQuery({
+    queryKey: ['import-history'],
+    queryFn: list_import_history,
+    staleTime: 10_000,
+  });
+
+  // Resolve the effective folder based on current mode
+  const effectiveFolder = (() => {
+    switch (folderMode) {
+      case 'header':
+        return headerFolder;
+      case 'existing':
+      case 'custom':
+        return folder;
+    }
+  })();
+
+  const startPolling = useCallback((id: string) => {
+    if (pollRef.current) clearInterval(pollRef.current);
+    let retries = 0;
+    pollRef.current = setInterval(async () => {
+      try {
+        const p = await get_import_progress(id);
+        setProgress(p);
+        retries = 0;
+        if (p.status === 'Completed' || p.status === 'Failed') {
+          if (pollRef.current) clearInterval(pollRef.current);
+          setPhase('done');
+          refetchHistory();
+        }
+      } catch {
+        retries++;
+        if (retries > 5) {
+          if (pollRef.current) clearInterval(pollRef.current);
+          setPhase('idle');
+        }
+      }
+    }, 1000);
+  }, [refetchHistory]);
+
+  useEffect(() => {
+    return () => { if (pollRef.current) clearInterval(pollRef.current); };
+  }, []);
+
+  const handleFiles = useCallback(async (newFiles: FileList | File[]) => {
+    const arr = Array.from(newFiles) as File[];
+    const queued: QueuedFile[] = arr.map((f) => {
+      const ext = f.name.split('.').pop()?.toLowerCase() || '';
+      const isMbox = ext === 'mbox';
+      const max = isMbox ? MAX_MBOX : MAX_EML;
+      const typeOk = isValidFileType(f, ext);
+      return { file: f, sizeOk: f.size <= max, typeOk };
+    });
+
+    setFiles(queued);
+    setPhase('idle');
+    setProgress(null);
+    //setImportId(null);
+
+    // Extract folder hint from the first valid file
+    const firstOk = queued.find((q) => q.sizeOk && q.typeOk);
+    if (firstOk) {
+      try {
+        const hint = await extractFolderHint(firstOk.file);
+        if (hint) {
+          setFolderHint(hint);
+          setHeaderFolder(hint.name);
+        }
+      } catch {
+        // ignore
+      }
+    }
+  }, []);
+
+  const removeFile = (idx: number) => {
+    setFiles((prev) => prev.filter((_, i) => i !== idx));
+    if (files.length <= 1) {
+      setFolderHint(null);
+      setHeaderFolder('INBOX');
+    }
+  };
+
+  const handleAccountChange = (v: string) => {
+    setAccountId(v);
+    setFiles([]);
+    setFolderHint(null);
+    setHeaderFolder('INBOX');
+  };
+
+  const handleModeChange = (mode: FolderMode) => {
+    setFolderMode(mode);
+    // When switching to header mode, re-detect from files if available
+    if (mode === 'header' && files.length > 0) {
+      const firstOk = files.find((q) => q.sizeOk && q.typeOk);
+      if (firstOk) {
+        extractFolderHint(firstOk.file).then((hint) => {
+          if (hint) {
+            setFolderHint(hint);
+            setHeaderFolder(hint.name);
+          }
+        });
+      }
+    }
+  };
+
+  const importMutation = useMutation({
+    mutationFn: async () => {
+      if (!accountId || !files.length) return;
+      const file = files[0].file;
+      setPhase('uploading');
+      setUploadPct(0);
+      const result = await upload_import(
+        Number(accountId),
+        effectiveFolder,
+        file.name,
+        file,
+        (pct) => setUploadPct(pct),
+      );
+      //setImportId(result.import_id);
+      setProgress(result);
+      setPhase('processing');
+      startPolling(result.import_id);
+    },
+    onError: (err: any) => {
+      setPhase('idle');
+      toast({
+        title: t('common.failed'),
+        description: err?.response?.data?.message || err.message,
+        variant: 'destructive',
+      });
+    },
+  });
+
+  const canImport =
+    accountId && effectiveFolder.trim() && files.length > 0 && files.every((f) => f.sizeOk && f.typeOk) && phase === 'idle';
+
+  return (
+    <>
+      <FixedHeader />
+      <Main>
+        <div className="flex-1 space-y-6 p-6 md:p-8 max-w-3xl mx-auto">
+          <div>
+            <h1 className="text-xl font-bold tracking-tight">
+              {t('import.title', 'Import EML / MBOX')}
+            </h1>
+            <p className="text-sm text-muted-foreground mt-1">
+              {t('import.description', 'Import email files into a NoSync account. For larger files, use the CLI.')}
+            </p>
+          </div>
+
+          {/* Step 1: Target account */}
+          <Card>
+            <CardHeader className="pb-3">
+              <CardTitle className="text-sm font-medium">
+                {t('import.target', '1. Select target account')}
+              </CardTitle>
+            </CardHeader>
+            <CardContent>
+              <div className="max-w-sm space-y-1.5">
+                <Label className="text-xs">{t('import.account')}</Label>
+                <Popover open={accountOpen} onOpenChange={setAccountOpen}>
+                  <PopoverTrigger asChild>
+                    <Button
+                      variant="outline"
+                      role="combobox"
+                      className="h-9 justify-between text-xs w-full"
+                    >
+                      <span className={cn('truncate', !accountId && 'text-muted-foreground')}>
+                        {accountId
+                          ? accounts.find((a) => String(a.id) === accountId)?.account_name
+                          || accounts.find((a) => String(a.id) === accountId)?.email
+                          || accountId
+                          : t('import.selectAccount')}
+                      </span>
+                      <ChevronsUpDown className="ml-2 h-3.5 w-3.5 shrink-0 opacity-50" />
+                    </Button>
+                  </PopoverTrigger>
+                  <PopoverContent className="w-[280px] p-0" align="start">
+                    <Command>
+                      <CommandInput
+                        placeholder={t('import.searchAccount', 'Search accounts...')}
+                        className="h-9 text-xs"
+                      />
+                      <CommandList>
+                        <CommandEmpty>
+                          {t('import.noAccountFound', 'No account found.')}
+                        </CommandEmpty>
+                        <CommandGroup>
+                          {accounts.map((a) => (
+                            <CommandItem
+                              key={a.id}
+                              value={a.account_name || a.email || String(a.id)}
+                              onSelect={() => {
+                                handleAccountChange(String(a.id));
+                                setAccountOpen(false);
+                              }}
+                              className='text-xs'
+                            >
+                              <Check
+                                className={cn(
+                                  'h-4 w-4',
+                                  accountId === String(a.id) ? 'opacity-100' : 'opacity-0',
+                                )}
+                              />
+                              {a.account_name || a.email}
+                            </CommandItem>
+                          ))}
+                        </CommandGroup>
+                      </CommandList>
+                    </Command>
+                  </PopoverContent>
+                </Popover>
+              </div>
+            </CardContent>
+          </Card>
+
+          {/* Step 2: Folder determination mode */}
+          <Card>
+            <CardHeader className="pb-3">
+              <CardTitle className="text-sm font-medium">
+                {t('import.folderMethod', '2. Choose folder method')}
+              </CardTitle>
+              <CardDescription className="text-xs">
+                {t('import.folderMethodDesc', 'How should the target mail folder be determined?')}
+              </CardDescription>
+            </CardHeader>
+            <CardContent className="space-y-4">
+              <RadioGroup
+                value={folderMode}
+                onValueChange={(v) => handleModeChange(v as FolderMode)}
+                className="gap-3"
+              >
+                {/* Mode 1: Auto-detect from headers */}
+                <label
+                  className={cn(
+                    'flex items-start gap-3 rounded-lg border p-3 cursor-pointer transition-colors',
+                    folderMode === 'header'
+                      ? 'border-primary bg-primary/5'
+                      : 'border-border hover:bg-muted/50',
+                  )}
+                >
+                  <RadioGroupItem value="header" id="mode-header" className="mt-0.5" />
+                  <div className="flex-1 min-w-0">
+                    <div className="flex items-center gap-2">
+                      <Sparkles className="h-4 w-4 text-primary" />
+                      <span className="text-sm font-medium">
+                        {t('import.modeHeader', 'Auto-detect from email headers')}
+                      </span>
+                    </div>
+                    <p className="text-xs text-muted-foreground mt-1">
+                      {t('import.modeHeaderDesc', 'Read X-Gmail-Labels / X-Bichon-Metadata from the uploaded file. Falls back to filename.')}
+                    </p>
+                    {folderMode === 'header' && (
+                      <div className="mt-2 flex items-center gap-2">
+                        <Badge variant="secondary" className="text-xs font-normal">
+                          {folderHint
+                            ? t('import.detectedFolder', 'Detected') + ': ' + headerFolder
+                            : t('import.noFileYet', 'No file selected yet')}
+                        </Badge>
+                        {folderHint && (
+                          <span className="text-[10px] text-muted-foreground">
+                            ({t('import.source')}: {folderHintLabel(folderHint)})
+                          </span>
+                        )}
+                      </div>
+                    )}
+                  </div>
+                </label>
+
+                {/* Mode 2: Pick from existing mailboxes */}
+                <label
+                  className={cn(
+                    'flex items-start gap-3 rounded-lg border p-3 cursor-pointer transition-colors',
+                    folderMode === 'existing'
+                      ? 'border-primary bg-primary/5'
+                      : 'border-border hover:bg-muted/50',
+                    !accountId && 'opacity-50 pointer-events-none',
+                  )}
+                >
+                  <RadioGroupItem value="existing" id="mode-existing" className="mt-0.5" disabled={!accountId} />
+                  <div className="flex-1 min-w-0">
+                    <div className="flex items-center gap-2">
+                      <ListTree className="h-4 w-4 text-primary" />
+                      <span className="text-sm font-medium">
+                        {t('import.modeExisting', 'Choose from existing mailboxes')}
+                      </span>
+                    </div>
+                    <p className="text-xs text-muted-foreground mt-1">
+                      {t('import.modeExistingDesc', 'Select one of the mailboxes already present in this account.')}
+                    </p>
+                    {folderMode === 'existing' && (
+                      <div className="mt-2">
+                        {mailboxes.length === 0 ? (
+                          <span className="text-xs text-muted-foreground">
+                            {accountId
+                              ? t('import.noMailboxes', 'No mailboxes found in this account.')
+                              : t('import.selectAccountFirst', 'Select an account first.')}
+                          </span>
+                        ) : (
+                          <Popover open={mailboxOpen} onOpenChange={setMailboxOpen}>
+                            <PopoverTrigger asChild>
+                              <Button
+                                variant="outline"
+                                role="combobox"
+                                className="h-8 justify-between text-xs max-w-xs w-full"
+                              >
+                                <span className="truncate">
+                                  {folder || t('import.selectMailbox', 'Select a mailbox...')}
+                                </span>
+                                <ChevronsUpDown className="ml-2 h-3.5 w-3.5 shrink-0 opacity-50" />
+                              </Button>
+                            </PopoverTrigger>
+                            <PopoverContent className="w-[280px] p-0" align="start">
+                              <Command>
+                                <CommandInput
+                                  placeholder={t('import.searchMailbox', 'Search mailboxes...')}
+                                  className="h-9 text-xs"
+                                />
+                                <CommandList>
+                                  <CommandEmpty>
+                                    {t('import.noMailboxFound', 'No mailbox found.')}
+                                  </CommandEmpty>
+                                  <CommandGroup>
+                                    {mailboxes.map((mb) => (
+                                      <CommandItem
+                                        key={mb.id}
+                                        value={mb.name}
+                                        onSelect={(value) => {
+                                          setFolder(value);
+                                          setMailboxOpen(false);
+                                        }}
+                                        className='text-xs'
+                                      >
+                                        <Check
+                                          className={cn(
+                                            'h-4 w-4',
+                                            folder === mb.name ? 'opacity-100' : 'opacity-0',
+                                          )}
+                                        />
+                                        {mb.name}
+                                      </CommandItem>
+                                    ))}
+                                  </CommandGroup>
+                                </CommandList>
+                              </Command>
+                            </PopoverContent>
+                          </Popover>
+                        )}
+                      </div>
+                    )}
+                  </div>
+                </label>
+
+                {/* Mode 3: Manual input */}
+                <label
+                  className={cn(
+                    'flex items-start gap-3 rounded-lg border p-3 cursor-pointer transition-colors',
+                    folderMode === 'custom'
+                      ? 'border-primary bg-primary/5'
+                      : 'border-border hover:bg-muted/50',
+                  )}
+                >
+                  <RadioGroupItem value="custom" id="mode-custom" className="mt-0.5" />
+                  <div className="flex-1 min-w-0">
+                    <div className="flex items-center gap-2">
+                      <PenLine className="h-4 w-4 text-primary" />
+                      <span className="text-sm font-medium">
+                        {t('import.modeCustom', 'Enter a custom folder name')}
+                      </span>
+                    </div>
+                    <p className="text-xs text-muted-foreground mt-1">
+                      {t('import.modeCustomDesc', 'Manually type the target mail folder name.')}
+                    </p>
+                    {folderMode === 'custom' && (
+                      <div className="mt-2">
+                        <Input
+                          className="h-8 text-xs max-w-xs"
+                          value={folder}
+                          onChange={(e) => setFolder(e.target.value)}
+                          placeholder="INBOX"
+                        />
+                      </div>
+                    )}
+                  </div>
+                </label>
+              </RadioGroup>
+            </CardContent>
+          </Card>
+
+          {/* Step 3: File upload */}
+          <Card>
+            <CardHeader className="pb-3">
+              <CardTitle className="text-sm font-medium">
+                {t('import.chooseFiles', '3. Choose files')}
+              </CardTitle>
+              <CardDescription className="text-xs">
+                {t('import.limits', 'Max: EML 100 MB · MBOX 1 GB. Larger files → CLI.')}
+              </CardDescription>
+            </CardHeader>
+            <CardContent>
+              <div
+                className={cn(
+                  'border-2 border-dashed rounded-lg p-8 text-center cursor-pointer transition-colors',
+                  dragging ? 'border-primary bg-primary/5' : 'border-muted-foreground/25 hover:border-muted-foreground/50',
+                  phase !== 'idle' && 'pointer-events-none opacity-50',
+                )}
+                onDragOver={(e) => { e.preventDefault(); setDragging(true); }}
+                onDragLeave={() => setDragging(false)}
+                onDrop={(e) => { e.preventDefault(); setDragging(false); handleFiles(e.dataTransfer.files); }}
+                onClick={() => {
+                  const input = document.createElement('input');
+                  input.type = 'file';
+                  input.accept = '.eml,.mbox,message/rfc822,application/mbox,text/plain';
+                  input.multiple = true;
+                  input.onchange = () => input.files && handleFiles(input.files);
+                  input.click();
+                }}
+              >
+                <Upload className="mx-auto h-10 w-10 text-muted-foreground/60 mb-3" />
+                <p className="text-sm font-medium">
+                  {t('import.dropHere', 'Drop .eml / .mbox files here')}
+                </p>
+                <p className="text-xs text-muted-foreground mt-1">
+                  {t('import.orClick', 'or click to browse')}
+                </p>
+              </div>
+
+              {files.length > 0 && (
+                <div className="mt-4 space-y-2">
+                  {files.map((qf, i) => (
+                    <div
+                      key={i}
+                      className={cn(
+                        'flex items-center gap-3 px-3 py-2 rounded-md border text-sm',
+                        qf.sizeOk && qf.typeOk
+                          ? 'bg-muted/30 border-border'
+                          : 'bg-destructive/5 border-destructive/30 text-destructive',
+                      )}
+                    >
+                      <FileText className="h-4 w-4 shrink-0" />
+                      <span className="flex-1 truncate">{qf.file.name}</span>
+                      <span className={cn('text-xs shrink-0', qf.sizeOk && qf.typeOk ? 'text-muted-foreground' : 'font-medium')}>
+                        {formatSize(qf.file.size)}
+                      </span>
+                      {!qf.typeOk && (
+                        <span className="text-xs font-medium text-destructive shrink-0">Invalid type</span>
+                      )}
+                      {!qf.sizeOk && qf.typeOk && (
+                        <span className="text-xs font-medium text-destructive shrink-0">Too large</span>
+                      )}
+                      {qf.sizeOk && qf.typeOk ? (
+                        <CheckCircle2 className="h-4 w-4 text-green-600 shrink-0" />
+                      ) : (
+                        <AlertTriangle className="h-4 w-4 shrink-0" />
+                      )}
+                      {phase === 'idle' && (
+                        <button
+                          type="button"
+                          onClick={(e) => { e.stopPropagation(); removeFile(i); }}
+                          className="p-0.5 hover:bg-muted rounded"
+                        >
+                          <X className="h-3.5 w-3.5" />
+                        </button>
+                      )}
+                    </div>
+                  ))}
+                </div>
+              )}
+            </CardContent>
+          </Card>
+
+          {/* Step 4: Progress & Results */}
+          {(phase !== 'idle' || progress) && (
+            <Card>
+              <CardHeader className="pb-3">
+                <CardTitle className="text-sm font-medium">
+                  {phase === 'uploading' && t('import.uploading', 'Uploading…')}
+                  {phase === 'processing' && t('import.processing', 'Processing…')}
+                  {phase === 'done' && (progress?.status === 'Completed' ? t('import.completed', 'Import complete') : t('import.failed', 'Import failed'))}
+                </CardTitle>
+              </CardHeader>
+              <CardContent className="space-y-4">
+                {phase === 'uploading' && (
+                  <div className="space-y-1.5">
+                    <div className="flex justify-between text-xs text-muted-foreground">
+                      <span>{t('import.uploadingFile')}</span>
+                      <span>{uploadPct}%</span>
+                    </div>
+                    <Progress value={uploadPct} className="h-2" />
+                  </div>
+                )}
+
+                {progress && progress.total > 0 && (
+                  <div className="space-y-1.5">
+                    <div className="flex justify-between text-xs text-muted-foreground">
+                      <span>
+                        {t('import.processed', { current: progress.success + progress.failed, total: progress.total })}
+                      </span>
+                      <span>
+                        {progress.total > 0
+                          ? Math.round(((progress.success + progress.failed) / progress.total) * 100)
+                          : 0}%
+                      </span>
+                    </div>
+                    <Progress
+                      value={progress.total > 0 ? ((progress.success + progress.failed) / progress.total) * 100 : 0}
+                      className="h-2"
+                    />
+                  </div>
+                )}
+
+                {progress && progress.total > 0 && (
+                  <div className="flex gap-4 text-xs">
+                    <span className="flex items-center gap-1">
+                      <CheckCircle2 className="h-3.5 w-3.5 text-green-600" />
+                      {t('import.successCount', { count: progress.success })}
+                    </span>
+                    <span className="flex items-center gap-1">
+                      <AlertTriangle className="h-3.5 w-3.5 text-amber-600" />
+                      {t('import.failedCount', { count: progress.failed })}
+                    </span>
+                  </div>
+                )}
+
+                {progress && progress.failed_details.length > 0 && (
+                  <details className="text-xs">
+                    <summary className="cursor-pointer text-muted-foreground hover:text-foreground">
+                      {t('import.failedDetails', 'Failed items')} ({progress.failed_details.length})
+                    </summary>
+                    <ScrollArea className="h-32 mt-2">
+                      <div className="space-y-1">
+                        {progress.failed_details.map((d, i) => (
+                          <div key={i} className="text-muted-foreground font-mono text-[11px]">
+                            #{d.index}: {d.error_message}
+                          </div>
+                        ))}
+                      </div>
+                    </ScrollArea>
+                  </details>
+                )}
+              </CardContent>
+            </Card>
+          )}
+
+          {/* Import button */}
+          <div className="flex justify-between items-center">
+            <div className="text-xs text-muted-foreground">
+              {t('import.willImportTo', 'Will import to')}: <span className="font-medium text-foreground">{effectiveFolder}</span>
+            </div>
+            <Button
+              onClick={() => importMutation.mutate()}
+              disabled={!canImport || importMutation.isPending}
+              className="gap-2"
+            >
+              {importMutation.isPending ? (
+                <Upload className="h-4 w-4 animate-pulse" />
+              ) : (
+                <Upload className="h-4 w-4" />
+              )}
+              {t('import.startImport', 'Import')}
+            </Button>
+          </div>
+
+          {/* Import history */}
+          {history.length > 0 && (
+            <CollapsibleHistory
+              history={history}
+              t={t}
+              accountLabel={(id: number) =>
+                accounts.find((a) => a.id === id)?.account_name
+                || accounts.find((a) => a.id === id)?.email
+                || String(id)
+              }
+            />
+          )}
+        </div>
+      </Main>
+    </>
+  );
+}
+
+// ─── Import history collapsible ──────────────────────────────────────────
+
+function statusColor(status: string) {
+  switch (status) {
+    case 'completed': return 'text-green-600';
+    case 'failed': return 'text-destructive';
+    case 'processing': return 'text-amber-600';
+    default: return 'text-muted-foreground';
+  }
+}
+
+function statusLabel(status: string) {
+  switch (status) {
+    case 'completed': return 'Completed';
+    case 'failed': return 'Failed';
+    case 'processing': return 'Processing';
+    case 'pending': return 'Pending';
+    default: return status;
+  }
+}
+
+function timeAgo(ts: number) {
+  const seconds = Math.floor((Date.now() - ts) / 1000);
+  if (seconds < 60) return `${seconds}s ago`;
+  if (seconds < 3600) return `${Math.floor(seconds / 60)}m ago`;
+  if (seconds < 86400) return `${Math.floor(seconds / 3600)}h ago`;
+  return new Date(ts).toLocaleDateString();
+}
+
+function CollapsibleHistory({
+  history,
+  t,
+  accountLabel,
+}: {
+  history: ImportHistory[];
+  t: (key: string) => string;
+  accountLabel: (id: number) => string;
+}) {
+  const [open, setOpen] = useState(false);
+
+  return (
+    <div className="border rounded-lg">
+      <button
+        type="button"
+        onClick={() => setOpen(!open)}
+        className="w-full flex items-center gap-2 px-4 py-3 text-sm hover:bg-muted/50 transition-colors rounded-lg"
+      >
+        <Clock className="h-4 w-4 text-muted-foreground" />
+        <span className="font-medium">
+          {t('import.importHistory')}
+        </span>
+        <span className="text-xs text-muted-foreground">
+          ({history.length})
+        </span>
+        <ChevronRight
+          className={cn(
+            'h-4 w-4 ml-auto text-muted-foreground transition-transform',
+            open && 'rotate-90',
+          )}
+        />
+      </button>
+      {open && (
+        <div className="border-t">
+          <div className="divide-y">
+            {history.map((h) => (
+              <div key={h.id} className="px-4 py-3 text-xs space-y-1.5">
+                <div className="flex items-center justify-between">
+                  <div className="flex items-center gap-2">
+                    <span className={cn('font-medium', statusColor(h.status))}>
+                      {statusLabel(h.status)}
+                    </span>
+                    <span className="text-muted-foreground">
+                      {accountLabel(h.account_id)} / {h.folder}
+                    </span>
+                  </div>
+                  <span className="text-muted-foreground">{timeAgo(h.created_at)}</span>
+                </div>
+                <div className="flex items-center gap-3 text-muted-foreground">
+                  <span>{h.format.toUpperCase()}</span>
+                  <span className="text-green-600">{h.success} success</span>
+                  {h.duplicates > 0 && <span>{h.duplicates} dup</span>}
+                  {h.failed > 0 && <span className="text-destructive">{h.failed} failed</span>}
+                  <span>{h.total} total</span>
+                </div>
+                {h.failed_details.length > 0 && (
+                  <details className="text-[11px]">
+                    <summary className="cursor-pointer text-muted-foreground hover:text-foreground">
+                      {t('import.failedDetails')} ({h.failed_details.length})
+                    </summary>
+                    <div className="mt-1 space-y-0.5 max-h-24 overflow-y-auto">
+                      {h.failed_details.map((d, i) => (
+                        <div key={i} className="text-muted-foreground font-mono">
+                          #{d.index}: {d.error_message}
+                        </div>
+                      ))}
+                    </div>
+                  </details>
+                )}
+              </div>
+            ))}
+          </div>
+        </div>
+      )}
+    </div>
+  );
+}

web/src/hooks/use-current-user.ts

@@ -64,6 +64,9 @@ export function useCurrentUser() {
           if (accountId !== undefined) {
             return accountMap.get(accountId)?.has(perm) ?? false
           }
+          for (const perms of accountMap.values()) {
+            if (perms.has(perm)) return true
+          }
           return false
         })
       }

web/src/locales/ar.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "يرجى تسجيل الدخول ببيانات الاعتماد المناسبة للوصول إلى هذا المورد.",
     "unauthorizedTitle": "وصول غير مصرح به"
   },
+  "import": {
+    "account": "الحساب",
+    "chooseFiles": "3. اختر الملفات",
+    "completed": "اكتمل الاستيراد",
+    "description": "استيراد ملفات البريد إلى حساب محلي (NoSync). للملفات الكبيرة، استخدم CLI.",
+    "detectedFolder": "مكتشف",
+    "detectedFrom": "مكتشف من",
+    "dropHere": "أفلت ملفات .eml / .mbox هنا",
+    "failed": "فشل الاستيراد",
+    "failedCount": "{{count}} فشل",
+    "failedDetails": "العناصر الفاشلة",
+    "folder": "المجلد",
+    "folderMethod": "2. اختر طريقة تحديد المجلد",
+    "folderMethodDesc": "كيف سيتم تحديد مجلد البريد المستهدف؟",
+    "importHistory": "سجل الاستيراد",
+    "limits": "الحد الأقصى: EML 100 م.ب · MBOX 1 غ.ب. للملفات الأكبر ← CLI.",
+    "modeCustom": "أدخل اسم مجلد مخصص",
+    "modeCustomDesc": "اكتب اسم مجلد البريد المستهدف يدويًا.",
+    "modeExisting": "اختر من صناديق البريد الحالية",
+    "modeExistingDesc": "حدد أحد صناديق البريد الموجودة بالفعل في هذا الحساب.",
+    "modeHeader": "كشف تلقائي من ترويسات البريد",
+    "modeHeaderDesc": "قراءة X-Gmail-Labels / X-Bichon-Metadata من الملف. يعتمد على اسم الملف كبديل.",
+    "noAccountFound": "لم يتم العثور على حساب.",
+    "noFileYet": "لم يتم اختيار أي ملف بعد",
+    "noMailboxFound": "لم يتم العثور على صندوق بريد.",
+    "noMailboxes": "لم يتم العثور على صناديق بريد في هذا الحساب.",
+    "orClick": "أو انقر للتصفح",
+    "processed": "تم معالجة {{current}} / {{total}}",
+    "processing": "جاري المعالجة…",
+    "searchAccount": "البحث عن الحسابات...",
+    "searchMailbox": "البحث عن صناديق البريد...",
+    "selectAccount": "اختر حسابًا",
+    "selectAccountFirst": "يرجى اختيار حساب أولاً.",
+    "selectMailbox": "اختر صندوق بريد...",
+    "source": "المصدر",
+    "startImport": "استيراد",
+    "successCount": "تم استيراد {{count}}",
+    "target": "1. اختر الحساب المستهدف",
+    "title": "استيراد",
+    "uploading": "جاري الرفع…",
+    "uploadingFile": "جاري رفع الملف",
+    "willImportTo": "سيتم الاستيراد إلى"
+  },
   "mail": {
     "account": "الحساب",
     "attachments": "المرفقات",

web/src/locales/da.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "Log venligst ind med passende legitimationsoplysninger for at få adgang til denne ressource.",
     "unauthorizedTitle": "Uautoriseret adgang"
   },
+  "import": {
+    "account": "Konto",
+    "chooseFiles": "3. Vælg filer",
+    "completed": "Import fuldført",
+    "description": "Importer e-mailfiler til en lokal konto (NoSync). Brug CLI til større filer.",
+    "detectedFolder": "Registreret",
+    "detectedFrom": "Registreret fra",
+    "dropHere": "Slip .eml / .mbox-filer her",
+    "failed": "Import mislykkedes",
+    "failedCount": "{{count}} fejlet",
+    "failedDetails": "Fejlede elementer",
+    "folder": "Mappe",
+    "folderMethod": "2. Vælg mappemetode",
+    "folderMethodDesc": "Hvordan skal destinationsmappen bestemmes?",
+    "importHistory": "Importhistorik",
+    "limits": "Maks: EML 100 MB · MBOX 1 GB. Større filer → CLI.",
+    "modeCustom": "Indtast et brugerdefineret mappenavn",
+    "modeCustomDesc": "Skriv navnet på destinationsmappen manuelt.",
+    "modeExisting": "Vælg fra eksisterende postkasser",
+    "modeExistingDesc": "Vælg en af de postkasser, der allerede findes på denne konto.",
+    "modeHeader": "Registrer automatisk fra e-mailheadere",
+    "modeHeaderDesc": "Læs X-Gmail-Labels / X-Bichon-Metadata fra filen. Falder tilbage til filnavn.",
+    "noAccountFound": "Ingen konto fundet.",
+    "noFileYet": "Ingen fil valgt endnu",
+    "noMailboxFound": "Ingen postkasse fundet.",
+    "noMailboxes": "Ingen postkasser fundet på denne konto.",
+    "orClick": "eller klik for at gennemse",
+    "processed": "{{current}} / {{total}} behandlet",
+    "processing": "Behandler…",
+    "searchAccount": "Søg efter konti...",
+    "searchMailbox": "Søg efter postkasser...",
+    "selectAccount": "Vælg en konto",
+    "selectAccountFirst": "Vælg en konto først.",
+    "selectMailbox": "Vælg en postkasse...",
+    "source": "kilde",
+    "startImport": "Importer",
+    "successCount": "{{count}} importeret",
+    "target": "1. Vælg målkonto",
+    "title": "Import",
+    "uploading": "Uploader…",
+    "uploadingFile": "Uploader fil",
+    "willImportTo": "Vil blive importeret til"
+  },
   "mail": {
     "account": "Konto",
     "attachments": "Vedhæftninger",

web/src/locales/de.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "Bitte melden Sie sich mit gültigen Anmeldeinformationen an, um auf diese Ressource zuzugreifen.",
     "unauthorizedTitle": "Nicht autorisierter Zugriff"
   },
+  "import": {
+    "account": "Konto",
+    "chooseFiles": "3. Dateien auswählen",
+    "completed": "Import abgeschlossen",
+    "description": "E-Mail-Dateien in ein lokales Konto (NoSync) importieren. Für größere Dateien CLI nutzen.",
+    "detectedFolder": "Erkannt",
+    "detectedFrom": "Erkannt aus",
+    "dropHere": ".eml / .mbox-Dateien hierher ziehen",
+    "failed": "Import fehlgeschlagen",
+    "failedCount": "{{count}} fehlgeschlagen",
+    "failedDetails": "Fehlgeschlagene Elemente",
+    "folder": "Ordner",
+    "folderMethod": "2. Ordnermethode wählen",
+    "folderMethodDesc": "Wie soll der Zielordner bestimmt werden?",
+    "importHistory": "Importverlauf",
+    "limits": "Max: EML 100 MB · MBOX 1 GB. Größere Dateien → CLI.",
+    "modeCustom": "Benutzerdefinierten Ordnernamen eingeben",
+    "modeCustomDesc": "Geben Sie den Namen des Zielordners manuell ein.",
+    "modeExisting": "Aus bestehenden Postfächern wählen",
+    "modeExistingDesc": "Wählen Sie ein bereits in diesem Konto vorhandenes Postfach aus.",
+    "modeHeader": "Automatisch aus E-Mail-Headern erkennen",
+    "modeHeaderDesc": "Liest X-Gmail-Labels / X-Bichon-Metadata aus der Datei. Fallback auf Dateiname.",
+    "noAccountFound": "Kein Konto gefunden.",
+    "noFileYet": "Noch keine Datei ausgewählt",
+    "noMailboxFound": "Kein Postfach gefunden.",
+    "noMailboxes": "Keine Postfächer in diesem Konto gefunden.",
+    "orClick": "oder zum Durchsuchen klicken",
+    "processed": "{{current}} / {{total}} verarbeitet",
+    "processing": "Verarbeitung…",
+    "searchAccount": "Konten suchen...",
+    "searchMailbox": "Postfächer suchen...",
+    "selectAccount": "Konto auswählen",
+    "selectAccountFirst": "Wählen Sie zuerst ein Konto aus.",
+    "selectMailbox": "Postfach auswählen...",
+    "source": "Quelle",
+    "startImport": "Importieren",
+    "successCount": "{{count}} importiert",
+    "target": "1. Zielkonto auswählen",
+    "title": "Import",
+    "uploading": "Hochladen…",
+    "uploadingFile": "Datei wird hochgeladen",
+    "willImportTo": "Wird importiert in"
+  },
   "mail": {
     "account": "Konto",
     "attachments": "Anhänge",

web/src/locales/en.json

@@ -591,6 +591,49 @@
     "unauthorizedDesc": "Please log in with the appropriate credentials to access this resource.",
     "unauthorizedTitle": "Unauthorized Access"
   },
+  "import": {
+    "account": "Account",
+    "chooseFiles": "3. Choose files",
+    "completed": "Import complete",
+    "description": "Import email files into a local account (NoSync). For larger files, use the CLI.",
+    "detectedFolder": "Detected",
+    "detectedFrom": "Detected from",
+    "dropHere": "Drop .eml / .mbox files here",
+    "failed": "Import failed",
+    "failedCount": "{{count}} failed",
+    "failedDetails": "Failed items",
+    "folder": "Folder",
+    "folderMethod": "2. Choose folder method",
+    "folderMethodDesc": "How should the target mail folder be determined?",
+    "importHistory": "Import History",
+    "limits": "Max: EML 100 MB · MBOX 1 GB. Larger files → CLI.",
+    "modeCustom": "Enter a custom folder name",
+    "modeCustomDesc": "Manually type the target mail folder name.",
+    "modeExisting": "Choose from existing mailboxes",
+    "modeExistingDesc": "Select one of the mailboxes already present in this account.",
+    "modeHeader": "Auto-detect from email headers",
+    "modeHeaderDesc": "Read X-Gmail-Labels / X-Bichon-Metadata from the uploaded file. Falls back to filename.",
+    "noAccountFound": "No account found.",
+    "noFileYet": "No file selected yet",
+    "noMailboxFound": "No mailbox found.",
+    "noMailboxes": "No mailboxes found in this account.",
+    "orClick": "or click to browse",
+    "processed": "{{current}} / {{total}} processed",
+    "processing": "Processing…",
+    "searchAccount": "Search accounts...",
+    "searchMailbox": "Search mailboxes...",
+    "selectAccount": "Select an account",
+    "selectAccountFirst": "Select an account first.",
+    "selectMailbox": "Select a mailbox...",
+    "source": "source",
+    "startImport": "Import",
+    "successCount": "{{count}} imported",
+    "target": "1. Select target account",
+    "title": "Import",
+    "uploading": "Uploading…",
+    "uploadingFile": "Uploading file",
+    "willImportTo": "Will import to"
+  },
   "mail": {
     "account": "Account",
     "attachments": "Attachments",

web/src/locales/es.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "Inicia sesión con credenciales válidas para acceder a este recurso.",
     "unauthorizedTitle": "Acceso no autorizado"
   },
+  "import": {
+    "account": "Cuenta",
+    "chooseFiles": "3. Seleccionar archivos",
+    "completed": "Importación completada",
+    "description": "Importar archivos de correo a una cuenta local (NoSync). Para archivos más grandes, use la CLI.",
+    "detectedFolder": "Detectado",
+    "detectedFrom": "Detectado de",
+    "dropHere": "Arrastre archivos .eml / .mbox aquí",
+    "failed": "Error al importar",
+    "failedCount": "{{count}} fallidos",
+    "failedDetails": "Elementos fallidos",
+    "folder": "Carpeta",
+    "folderMethod": "2. Elegir método de carpeta",
+    "folderMethodDesc": "¿Cómo se debe determinar la carpeta de correo de destino?",
+    "importHistory": "Historial de importación",
+    "limits": "Máx: EML 100 MB · MBOX 1 GB. Archivos más grandes → CLI.",
+    "modeCustom": "Ingresar un nombre de carpeta personalizado",
+    "modeCustomDesc": "Escriba manualmente el nombre de la carpeta de destino.",
+    "modeExisting": "Elegir de buzones existentes",
+    "modeExistingDesc": "Seleccione uno de los buzones ya presentes en esta cuenta.",
+    "modeHeader": "Detectar automáticamente de cabeceras",
+    "modeHeaderDesc": "Lee X-Gmail-Labels / X-Bichon-Metadata del archivo. Alternativa: nombre del archivo.",
+    "noAccountFound": "No se encontró ninguna cuenta.",
+    "noFileYet": "Ningún archivo seleccionado",
+    "noMailboxFound": "No se encontró ningún buzón.",
+    "noMailboxes": "No se encontraron buzones en esta cuenta.",
+    "orClick": "o haga clic para buscar",
+    "processed": "{{current}} / {{total}} procesados",
+    "processing": "Procesando…",
+    "searchAccount": "Buscar cuentas...",
+    "searchMailbox": "Buscar buzones...",
+    "selectAccount": "Seleccionar una cuenta",
+    "selectAccountFirst": "Seleccione una cuenta primero.",
+    "selectMailbox": "Seleccionar buzón...",
+    "source": "origen",
+    "startImport": "Importar",
+    "successCount": "{{count}} importados",
+    "target": "1. Seleccionar cuenta de destino",
+    "title": "Importar",
+    "uploading": "Subiendo…",
+    "uploadingFile": "Subiendo archivo",
+    "willImportTo": "Se importará a"
+  },
   "mail": {
     "account": "Cuenta",
     "attachments": "Adjuntos",

web/src/locales/fi.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "Kirjaudu sisään oikeilla tunnuksilla päästäksesi tähän resurssiin.",
     "unauthorizedTitle": "Luvaton pääsy"
   },
+  "import": {
+    "account": "Tili",
+    "chooseFiles": "3. Valitse tiedostot",
+    "completed": "Tuonti valmis",
+    "description": "Tuo sähköpostitiedostoja paikalliselle tilille (NoSync). Käytä CLI:tä suuremmille tiedostoille.",
+    "detectedFolder": "Tunnistettu",
+    "detectedFrom": "Tunnistettu lähteestä",
+    "dropHere": "Pudota .eml / .mbox -tiedostot tähän",
+    "failed": "Tuonti epäonnistui",
+    "failedCount": "{{count}} epäonnistui",
+    "failedDetails": "Epäonnistuneet kohteet",
+    "folder": "Kansio",
+    "folderMethod": "2. Valitse kansiomenetelmä",
+    "folderMethodDesc": "Miten kohdekansio tulisi määrittää?",
+    "importHistory": "Tuontihistoria",
+    "limits": "Max: EML 100 MB · MBOX 1 GB. Suuremmat tiedostot → CLI.",
+    "modeCustom": "Syötä mukautettu kansion nimi",
+    "modeCustomDesc": "Kirjoita kohdekansion nimi manuaalisesti.",
+    "modeExisting": "Valitse olemassa olevista postilaatikoista",
+    "modeExistingDesc": "Valitse jokin tällä tilillä jo olevista postilaatikoista.",
+    "modeHeader": "Tunnista automaattisesti sähköpostiviestien otsakkeista",
+    "modeHeaderDesc": "Lue X-Gmail-Labels / X-Bichon-Metadata tiedostosta. Varajärjestelmänä tiedostonimi.",
+    "noAccountFound": "Tiliä ei löytynyt.",
+    "noFileYet": "Ei valittua tiedostoa",
+    "noMailboxFound": "Postilaatikkoa ei löytynyt.",
+    "noMailboxes": "Tältä tililtä ei löytynyt postilaatikoita.",
+    "orClick": "tai napsauta selataksesi",
+    "processed": "{{current}} / {{total}} käsitelty",
+    "processing": "Käsitellään…",
+    "searchAccount": "Etsi tilejä...",
+    "searchMailbox": "Etsi postilaatikoita...",
+    "selectAccount": "Valitse tili",
+    "selectAccountFirst": "Valitse ensin tili.",
+    "selectMailbox": "Valitse postilaatikko...",
+    "source": "lähde",
+    "startImport": "Tuo",
+    "successCount": "{{count}} tuotu",
+    "target": "1. Valitse kohdetili",
+    "title": "Tuonti",
+    "uploading": "Ladataan…",
+    "uploadingFile": "Ladataan tiedostoa",
+    "willImportTo": "Tuodaan kohteeseen"
+  },
   "mail": {
     "account": "Tili",
     "attachments": "Liitteet",

web/src/locales/fr.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "Veuillez vous connecter avec les informations d'identification appropriées pour accéder à cette ressource.",
     "unauthorizedTitle": "Accès Non Autorisé"
   },
+  "import": {
+    "account": "Compte",
+    "chooseFiles": "3. Choisir les fichiers",
+    "completed": "Importation terminée",
+    "description": "Importer des fichiers d'e-mails dans un compte local (NoSync). Pour les gros fichiers, utilisez le CLI.",
+    "detectedFolder": "Détecté",
+    "detectedFrom": "Détecté depuis",
+    "dropHere": "Déposez les fichiers .eml / .mbox ici",
+    "failed": "Échec de l'importation",
+    "failedCount": "{{count}} échoué(s)",
+    "failedDetails": "Éléments en échec",
+    "folder": "Dossier",
+    "folderMethod": "2. Choisir la méthode de dossier",
+    "folderMethodDesc": "Comment le dossier de destination doit-il être déterminé ?",
+    "importHistory": "Historique d'importation",
+    "limits": "Max : EML 100 MB · MBOX 1 GB. Fichiers plus volumineux → CLI.",
+    "modeCustom": "Saisir un nom de dossier personnalisé",
+    "modeCustomDesc": "Saisissez manuellement le nom du dossier de destination.",
+    "modeExisting": "Choisir parmi les boîtes existantes",
+    "modeExistingDesc": "Sélectionnez l'une des boîtes aux lettres déjà présentes dans ce compte.",
+    "modeHeader": "Détection auto depuis les en-têtes",
+    "modeHeaderDesc": "Lit X-Gmail-Labels / X-Bichon-Metadata depuis le fichier. Alternative : nom du fichier.",
+    "noAccountFound": "Aucun compte trouvé.",
+    "noFileYet": "Aucun fichier sélectionné",
+    "noMailboxFound": "Aucune boîte aux lettres trouvée.",
+    "noMailboxes": "Aucune boîte aux lettres trouvée dans ce compte.",
+    "orClick": "ou cliquez pour parcourir",
+    "processed": "{{current}} / {{total}} traités",
+    "processing": "Traitement…",
+    "searchAccount": "Rechercher des comptes...",
+    "searchMailbox": "Rechercher des boîtes...",
+    "selectAccount": "Sélectionner un compte",
+    "selectAccountFirst": "Sélectionnez d'abord un compte.",
+    "selectMailbox": "Sélectionner une boîte...",
+    "source": "source",
+    "startImport": "Importer",
+    "successCount": "{{count}} importé(s)",
+    "target": "1. Sélectionner le compte cible",
+    "title": "Importer",
+    "uploading": "Téléversement…",
+    "uploadingFile": "Téléversement du fichier",
+    "willImportTo": "Sera importé dans"
+  },
   "mail": {
     "account": "Compte",
     "attachments": "Pièces jointes",

web/src/locales/it.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "Accedi con le credenziali corrette per accedere a questa risorsa.",
     "unauthorizedTitle": "Accesso non Autorizzato"
   },
+  "import": {
+    "account": "Account",
+    "chooseFiles": "3. Scegli i file",
+    "completed": "Importazione completata",
+    "description": "Importa file email in un account locale (NoSync). Per file più grandi, usa la CLI.",
+    "detectedFolder": "Rilevato",
+    "detectedFrom": "Rilevato da",
+    "dropHere": "Trascina i file .eml / .mbox qui",
+    "failed": "Importazione fallita",
+    "failedCount": "{{count}} falliti",
+    "failedDetails": "Elementi falliti",
+    "folder": "Cartella",
+    "folderMethod": "2. Scegli il metodo della cartella",
+    "folderMethodDesc": "Come determinare la cartella di posta di destinazione?",
+    "importHistory": "Cronologia importazioni",
+    "limits": "Max: EML 100 MB · MBOX 1 GB. File più grandi → CLI.",
+    "modeCustom": "Inserisci un nome cartella personalizzato",
+    "modeCustomDesc": "Digita manualmente il nome della cartella di destinazione.",
+    "modeExisting": "Scegli tra le caselle esistenti",
+    "modeExistingDesc": "Seleziona una delle caselle già presenti in questo account.",
+    "modeHeader": "Rilevamento automatico dagli header",
+    "modeHeaderDesc": "Legge X-Gmail-Labels / X-Bichon-Metadata dal file. Alternativa: nome del file.",
+    "noAccountFound": "Nessun account trovato.",
+    "noFileYet": "Nessun file selezionato",
+    "noMailboxFound": "Nessuna casella postale trouvata.",
+    "noMailboxes": "Nessuna casella postale trovata in questo account.",
+    "orClick": "o clicca per sfogliare",
+    "processed": "{{current}} / {{total}} elaborati",
+    "processing": "Elaborazione…",
+    "searchAccount": "Cerca account...",
+    "searchMailbox": "Cerca caselle postali...",
+    "selectAccount": "Seleziona un account",
+    "selectAccountFirst": "Seleziona prima un account.",
+    "selectMailbox": "Seleziona una casella...",
+    "source": "origine",
+    "startImport": "Importa",
+    "successCount": "{{count}} importati",
+    "target": "1. Seleziona account di destinazione",
+    "title": "Importa",
+    "uploading": "Caricamento…",
+    "uploadingFile": "Caricamento del file",
+    "willImportTo": "Sarà importato in"
+  },
   "mail": {
     "account": "Account",
     "attachments": "Allegati",

web/src/locales/jp.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "このリソースにアクセスするには、適切な資格情報でログインしてください。",
     "unauthorizedTitle": "不正アクセス"
   },
+  "import": {
+    "account": "アカウント",
+    "chooseFiles": "3. ファイルを選択",
+    "completed": "インポート完了",
+    "description": "NoSyncローカルアカウントにメールファイルをインポートします。大容量ファイルはCLIを使用してください。",
+    "detectedFolder": "放出演出",
+    "detectedFrom": "検出元:",
+    "dropHere": "ここに .eml / .mbox ファイルをドロップ",
+    "failed": "インポート失敗",
+    "failedCount": "{{count}} 件の失敗",
+    "failedDetails": "失敗したアイテム",
+    "folder": "フォルダ",
+    "folderMethod": "2. フォルダ指定方法の選択",
+    "folderMethodDesc": "インポート先のフォルダをどのように決定しますか？",
+    "importHistory": "インポート履歴",
+    "limits": "上限: EML 100 MB · MBOX 1 GB。これ以上のサイズは → CLIへ。",
+    "modeCustom": "カスタムフォルダ名を入力",
+    "modeCustomDesc": "インポート先のフォルダ名を手動で入力します。",
+    "modeExisting": "既存のメールボックスから選択",
+    "modeExistingDesc": "このアカウントに既に存在するメールボックスから選択します。",
+    "modeHeader": "メールヘッダーから自动検出",
+    "modeHeaderDesc": "ファイルから X-Gmail-Labels / X-Bichon-Metadata を読み取ります。ない場合はファイル名を使用します。",
+    "noAccountFound": "アカウントが見つかりません。",
+    "noFileYet": "ファイルが選択されていません",
+    "noMailboxFound": "メールボックスが見つかりません。",
+    "noMailboxes": "このアカウントにメールボックスが見つかりません。",
+    "orClick": "またはクリックしてファイルを選択",
+    "processed": "{{current}} / {{total}} 件を処理済み",
+    "processing": "処理中…",
+    "searchAccount": "アカウントを検索...",
+    "searchMailbox": "メールボックスを検索...",
+    "selectAccount": "アカウントを選択",
+    "selectAccountFirst": "最初にアカウントを選択してください。",
+    "selectMailbox": "メールボックスを選択...",
+    "source": "ソース",
+    "startImport": "インポート",
+    "successCount": "{{current}} 件を処理済み",
+    "target": "1. 対象アカウントの選択",
+    "title": "インポート",
+    "uploading": "アップロード中…",
+    "uploadingFile": "ファイルをアップロード中",
+    "willImportTo": "インポート先:"
+  },
   "mail": {
     "account": "アカウント",
     "attachments": "添付ファイル",

web/src/locales/ko.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "이 리소스에 접근하려면 적절한 자격 증명으로 로그인하십시오.",
     "unauthorizedTitle": "승인되지 않은 접근"
   },
+  "import": {
+    "account": "계정",
+    "chooseFiles": "3. 파일 선택",
+    "completed": "가져오기 완료",
+    "description": "로컬 계정(NoSync)으로 이메일 파일을 가져옵니다. 대용량 파일은 CLI를 사용하세요.",
+    "detectedFolder": "감지됨",
+    "detectedFrom": "감지 대상:",
+    "dropHere": "여기에 .eml / .mbox 파일 끌어놓기",
+    "failed": "가져오기 실패",
+    "failedCount": "{{count}}개 실패",
+    "failedDetails": "실패한 항목",
+    "folder": "폴더",
+    "folderMethod": "2. 폴더 지정 방식 선택",
+    "folderMethodDesc": "가져올 메일 폴더를 어떻게 결정하시겠습니까?",
+    "importHistory": "가져오기 기록",
+    "limits": "제한: EML 100 MB · MBOX 1 GB. 더 큰 파일은 → CLI 사용.",
+    "modeCustom": "사용자 지정 폴더 이름 입력",
+    "modeCustomDesc": "가져올 메일 폴더 이름을 수동으로 입력합니다.",
+    "modeExisting": "기존 편지함에서 선택",
+    "modeExistingDesc": "이 계정에 이미 존재하는 편지함 중 하나를 선택합니다.",
+    "modeHeader": "이메일 헤더에서 자동 감지",
+    "modeHeaderDesc": "파일에서 X-Gmail-Labels / X-Bichon-Metadata를 읽습니다. 없을 경우 파일명을 사용합니다.",
+    "noAccountFound": "계정을 찾을 수 없습니다.",
+    "noFileYet": "선택된 파일 없음",
+    "noMailboxFound": "편지함을 찾을 수 없습니다.",
+    "noMailboxes": "이 계정에서 편지함을 찾을 수 없습니다.",
+    "orClick": "또는 클릭하여 찾아보기",
+    "processed": "{{current}} / {{total}} 처리됨",
+    "processing": "처리 중…",
+    "searchAccount": "계정 검색...",
+    "searchMailbox": "편지함 검색...",
+    "selectAccount": "계정 선택",
+    "selectAccountFirst": "계정을 먼저 선택해 주세요.",
+    "selectMailbox": "편지함 선택...",
+    "source": "소스",
+    "startImport": "가져오기",
+    "successCount": "{{count}}개 가져옴",
+    "target": "1. 대상 계정 선택",
+    "title": "가져오기",
+    "uploading": "업로드 중…",
+    "uploadingFile": "파일 업로드 중",
+    "willImportTo": "가져올 위치:"
+  },
   "mail": {
     "account": "계정",
     "attachments": "첨부 파일",

web/src/locales/nl.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "Log in met de juiste inloggegevens om deze bron te benaderen.",
     "unauthorizedTitle": "Ongeautoriseerde Toegang"
   },
+  "import": {
+    "account": "Account",
+    "chooseFiles": "3. Kies bestanden",
+    "completed": "Import voltooid",
+    "description": "Importeer e-mailbestanden in een lokaal account (NoSync). Gebruik de CLI voor grotere bestanden.",
+    "detectedFolder": "Gedetecteerd",
+    "detectedFrom": "Gedetecteerd uit",
+    "dropHere": "Sleep .eml / .mbox bestanden hierheen",
+    "failed": "Import mislukt",
+    "failedCount": "{{count}} mislukt",
+    "failedDetails": "Mislukte items",
+    "folder": "Map",
+    "folderMethod": "2. Kies mapmethode",
+    "folderMethodDesc": "Hoe moet de doelmap voor e-mail worden bepaald?",
+    "importHistory": "Importgeschiedenis",
+    "limits": "Max: EML 100 MB · MBOX 1 GB. Grotere bestanden → CLI.",
+    "modeCustom": "Voer een aangepaste mapnaam in",
+    "modeCustomDesc": "Typ handmatig de naam van de doelmap.",
+    "modeExisting": "Kies uit bestaande mailboxen",
+    "modeExistingDesc": "Selecteer een van de mailboxen die al in dit account aanwezig zijn.",
+    "modeHeader": "Automatisch detecteren uit e-mailheaders",
+    "modeHeaderDesc": "Leest X-Gmail-Labels / X-Bichon-Metadata uit het bestand. Valt terug op bestandsnaam.",
+    "noAccountFound": "Geen account gevonden.",
+    "noFileYet": "Nog geen bestand geselecteerd",
+    "noMailboxFound": "Geen mailbox gevonden.",
+    "noMailboxes": "Geen mailboxen gevonden in dit account.",
+    "orClick": "of klik om te bladeren",
+    "processed": "{{current}} / {{total}} verwerkt",
+    "processing": "Verwerken…",
+    "searchAccount": "Accounts zoeken...",
+    "searchMailbox": "Mailboxen zoeken...",
+    "selectAccount": "Selecteer een account",
+    "selectAccountFirst": "Selecteer eerst een account.",
+    "selectMailbox": "Selecteer een mailbox...",
+    "source": "bron",
+    "startImport": "Importeren",
+    "successCount": "{{count}} geïmporteerd",
+    "target": "1. Selecteer doelaccount",
+    "title": "Importeren",
+    "uploading": "Uploaden…",
+    "uploadingFile": "Bestand uploaden",
+    "willImportTo": "Zal importeren naar"
+  },
   "mail": {
     "account": "Account",
     "attachments": "Bijlagen",

web/src/locales/no.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "Vennligst logg inn med riktig legitimasjon for å få tilgang til denne ressursen.",
     "unauthorizedTitle": "Uautorisert tilgang"
   },
+  "import": {
+    "account": "Konto",
+    "chooseFiles": "3. Velg filer",
+    "completed": "Import fullført",
+    "description": "Importer e-postfiler til en lokal konto (NoSync). Bruk CLI for større filer.",
+    "detectedFolder": "Registrert",
+    "detectedFrom": "Registrert fra",
+    "dropHere": "Slipp .eml / .mbox-filer her",
+    "failed": "Import mislyktes",
+    "failedCount": "{{count}} feilet",
+    "failedDetails": "Feilede elementer",
+    "folder": "Mappe",
+    "folderMethod": "2. Velg mappemetode",
+    "folderMethodDesc": "Hvordan skal målmappen for e-post bestemmes?",
+    "importHistory": "Importhistorikk",
+    "limits": "Maks: EML 100 MB · MBOX 1 GB. Større filer → CLI.",
+    "modeCustom": "Skriv inn et egendefinert mappenavn",
+    "modeCustomDesc": "Skriv inn navnet på målmappen manuelt.",
+    "modeExisting": "Velg fra eksisterende postbokser",
+    "modeExistingDesc": "Velg en av postboksene som allerede finnes på denne konto.",
+    "modeHeader": "Registrer automatisk fra e-postheadere",
+    "modeHeaderDesc": "Leser X-Gmail-Labels / X-Bichon-Metadata fra filen. Faller tillbaka til filnavn.",
+    "noAccountFound": "Ingen konto fundet.",
+    "noFileYet": "Ingen fil valgt ennå",
+    "noMailboxFound": "Ingen postboks funnet.",
+    "noMailboxes": "Ingen postbokser funnet på denne kontoen.",
+    "orClick": "eller klikk for å bla gjennom",
+    "processed": "{{current}} / {{total}} behandlet",
+    "processing": "Behandler…",
+    "searchAccount": "Søk etter kontoer...",
+    "searchMailbox": "Søk etter postbokser...",
+    "selectAccount": "Velg en konto",
+    "selectAccountFirst": "Velg en konto først.",
+    "selectMailbox": "Velg en postboks...",
+    "source": "kilde",
+    "startImport": "Importer",
+    "successCount": "{{count}} importert",
+    "target": "1. Velg målkonto",
+    "title": "Import",
+    "uploading": "Laster opp…",
+    "uploadingFile": "Laster opp fil",
+    "willImportTo": "Vil bli importert til"
+  },
   "mail": {
     "account": "Konto",
     "attachments": "Vedlegg",

web/src/locales/pl.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "Aby uzyskać dostęp do tego zasobu, zaloguj się przy użyciu odpowiednich danych uwierzytelniających",
     "unauthorizedTitle": "Dostęp nieautoryzowany"
   },
+  "import": {
+    "account": "Konto",
+    "chooseFiles": "3. Wybierz pliki",
+    "completed": "Import zakończony",
+    "description": "Importuj pliki e-mail do konta lokalnego (NoSync). W przypadku większych plików użyj CLI.",
+    "detectedFolder": "Wykryto",
+    "detectedFrom": "Wykryto z",
+    "dropHere": "Upuść pliki .eml / .mbox tutaj",
+    "failed": "Import nie powiódł się",
+    "failedCount": "Niepowodzenie: {{count}}",
+    "failedDetails": "Nieudane elementy",
+    "folder": "Folder",
+    "folderMethod": "2. Wybierz metodę folderu",
+    "folderMethodDesc": "Jak ma zostać określony docelowy folder poczty?",
+    "importHistory": "Historia importu",
+    "limits": "Maks: EML 100 MB · MBOX 1 GB. Większe pliki → CLI.",
+    "modeCustom": "Wprowadź własną nazwę folderu",
+    "modeCustomDesc": "Ręcznie wpisz nazwę docelowego folderu poczty.",
+    "modeExisting": "Wybierz z istniejących skrzynek",
+    "modeExistingDesc": "Wybierz jedną ze skrzynek pocztowych już istniejących na tym koncie.",
+    "modeHeader": "Automatyczne wykrywanie z nagłówków",
+    "modeHeaderDesc": "Odczytaj X-Gmail-Labels / X-Bichon-Metadata z pliku. W przypadku braku użyta zostanie nazwa pliku.",
+    "noAccountFound": "Nie znaleziono konta.",
+    "noFileYet": "Nie wybrano jeszcze żadnego pliku",
+    "noMailboxFound": "Nie znaleziono skrzynki pocztowej.",
+    "noMailboxes": "Nie znaleziono skrzynek pocztowych na tym koncie.",
+    "orClick": "lub kliknij, aby przeglądać",
+    "processed": "Przetworzono: {{current}} / {{total}}",
+    "processing": "Przetwarzanie…",
+    "searchAccount": "Szukaj kont...",
+    "searchMailbox": "Szukaj skrzynek...",
+    "selectAccount": "Wybierz konto",
+    "selectAccountFirst": "Najpierw wybierz konto.",
+    "selectMailbox": "Wybierz skrzynkę...",
+    "source": "źródło",
+    "startImport": "Importuj",
+    "successCount": "Zaimportowano: {{count}}",
+    "target": "1. Wybierz konto docelowe",
+    "title": "Import",
+    "uploading": "Przesyłanie…",
+    "uploadingFile": "Przesyłanie pliku",
+    "willImportTo": "Zostanie zaimportowane do"
+  },
   "mail": {
     "account": "Konto",
     "attachments": "Załączniki",

web/src/locales/pt.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "Por favor, faça login com as credenciais apropriadas para acessar este recurso.",
     "unauthorizedTitle": "Acesso Não Autorizado"
   },
+  "import": {
+    "account": "Conta",
+    "chooseFiles": "3. Escolher arquivos",
+    "completed": "Importação concluída",
+    "description": "Importar arquivos de e-mail para uma conta local (NoSync). Para arquivos maiores, use a CLI.",
+    "detectedFolder": "Detectado",
+    "detectedFrom": "Detectado de",
+    "dropHere": "Solte arquivos .eml / .mbox aqui",
+    "failed": "Falha na importação",
+    "failedCount": "{{count}} falharam",
+    "failedDetails": "Itens com falha",
+    "folder": "Pasta",
+    "folderMethod": "2. Escolher método de pasta",
+    "folderMethodDesc": "Como a pasta de e-mail de destino deve ser determinada?",
+    "importHistory": "Histórico de importação",
+    "limits": "Máx: EML 100 MB · MBOX 1 GB. Arquivos maiores → CLI.",
+    "modeCustom": "Digitar um nome de pasta personalizado",
+    "modeCustomDesc": "Digite manualmente o nome da pasta de e-mail de destino.",
+    "modeExisting": "Escolher a partir de caixas existentes",
+    "modeExistingDesc": "Selecione uma das caixas de correio já presentes nesta conta.",
+    "modeHeader": "Detectar automaticamente dos cabeçalhos",
+    "modeHeaderDesc": "Lê X-Gmail-Labels / X-Bichon-Metadata do arquivo. Alternativa: nome do arquivo.",
+    "noAccountFound": "Nenhuma conta encontrada.",
+    "noFileYet": "Nenhum arquivo selecionado",
+    "noMailboxFound": "Nenhuma caixa de correio encontrada.",
+    "noMailboxes": "Nenhuma caixa de correio encontrada nesta conta.",
+    "orClick": "ou clique para navegar",
+    "processed": "{{current}} / {{total}} processados",
+    "processing": "Processando…",
+    "searchAccount": "Buscar contas...",
+    "searchMailbox": "Buscar caixas de correio...",
+    "selectAccount": "Selecionar uma conta",
+    "selectAccountFirst": "Selecione uma conta primeiro.",
+    "selectMailbox": "Selecionar caixa de correio...",
+    "source": "origem",
+    "startImport": "Importar",
+    "successCount": "{{count}} importados",
+    "target": "1. Selecionar conta de destino",
+    "title": "Importar",
+    "uploading": "Enviando…",
+    "uploadingFile": "Enviando arquivo",
+    "willImportTo": "Será importado para"
+  },
   "mail": {
     "account": "Conta",
     "attachments": "Anexos",

web/src/locales/ru.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "Пожалуйста, войдите с соответствующими учетными данными для доступа к этому ресурсу.",
     "unauthorizedTitle": "Несанкционированный доступ"
   },
+  "import": {
+    "account": "Аккаунт",
+    "chooseFiles": "3. Выбрать файлы",
+    "completed": "Импорт завершен",
+    "description": "Импорт файлов писем в локальный аккаунт (NoSync). Для больших файлов используйте CLI.",
+    "detectedFolder": "Обнаружено",
+    "detectedFrom": "Обнаружено из",
+    "dropHere": "Перетащите файлы .eml / .mbox сюда",
+    "failed": "Ошибка импорта",
+    "failedCount": "Ошибок: {{count}}",
+    "failedDetails": "Неудачные элементы",
+    "folder": "Папка",
+    "folderMethod": "2. Выберите метод определения папки",
+    "folderMethodDesc": "Как следует определять целевую папку для писем?",
+    "importHistory": "История импорта",
+    "limits": "Макс: EML 100 МБ · MBOX 1 ГБ. Для больших файлов → CLI.",
+    "modeCustom": "Ввести имя папки вручную",
+    "modeCustomDesc": "Введите имя целевой папки вручную.",
+    "modeExisting": "Выбрать из существующих ящиков",
+    "modeExistingDesc": "Выберите один из почтовых ящиков, уже существующих в этом аккаунте.",
+    "modeHeader": "Автоопределение из заголовков писем",
+    "modeHeaderDesc": "Чтение X-Gmail-Labels / X-Bichon-Metadata из файла. Если их нет, используется имя файла.",
+    "noAccountFound": "Аккаунт не найден.",
+    "noFileYet": "Файл еще не выбран",
+    "noMailboxFound": "Почтовый ящик не найден.",
+    "noMailboxes": "В этом аккаунте не найдено почтовых ящиков.",
+    "orClick": "или нажмите для обзора",
+    "processed": "Обработано: {{current}} / {{total}}",
+    "processing": "Обработка…",
+    "searchAccount": "Поиск аккаунтов...",
+    "searchMailbox": "Поиск почтовых ящиков...",
+    "selectAccount": "Выберите аккаунт",
+    "selectAccountFirst": "Сначала выберите аккаунт.",
+    "selectMailbox": "Выберите почтовый ящик...",
+    "source": "источник",
+    "startImport": "Импортировать",
+    "successCount": "Импортировано: {{count}}",
+    "target": "1. Выберите целевой аккаунт",
+    "title": "Импорт",
+    "uploading": "Загрузка…",
+    "uploadingFile": "Загрузка файла",
+    "willImportTo": "Будет импортировано в"
+  },
   "mail": {
     "account": "Аккаунт",
     "attachments": "Вложения",

web/src/locales/sv.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "Vänligen logga in med lämpliga uppgifter för att komma åt denna resurs.",
     "unauthorizedTitle": "Obehörig åtkomst"
   },
+  "import": {
+    "account": "Konto",
+    "chooseFiles": "3. Välj filer",
+    "completed": "Import slutförd",
+    "description": "Importera e-postfiler till ett lokalt konto (NoSync). Använd CLI för större filer.",
+    "detectedFolder": "Identifierad",
+    "detectedFrom": "Identifierad från",
+    "dropHere": "Släpp .eml / .mbox-filer här",
+    "failed": "Import misslyckades",
+    "failedCount": "{{count}} misslyckades",
+    "failedDetails": "Misslyckade objekt",
+    "folder": "Mapp",
+    "folderMethod": "2. Välj mappemetod",
+    "folderMethodDesc": "Hur ska målmappen for e-post bestämmas?",
+    "importHistory": "Importhistorik",
+    "limits": "Max: EML 100 MB · MBOX 1 GB. Större filer → CLI.",
+    "modeCustom": "Ange ett anpassat mappnamn",
+    "modeCustomDesc": "Ange namnet på målmappen manuellt.",
+    "modeExisting": "Välj från befintliga brevlådor",
+    "modeExistingDesc": "Välj en av de brevlådor som redan finns på detta konto.",
+    "modeHeader": "Identifiera automatiskt från e-posthuvuden",
+    "modeHeaderDesc": "Läser X-Gmail-Labels / X-Bichon-Metadata från filen. Faller tillbaka på filnamn.",
+    "noAccountFound": "Inget konto hittades.",
+    "noFileYet": "Ingen fil har valts än",
+    "noMailboxFound": "Ingen brevlåda hittades.",
+    "noMailboxes": "Inga brevlådor hittades på detta konto.",
+    "orClick": "eller klicka för att bläddra",
+    "processed": "{{current}} / {{total}} behandlade",
+    "processing": "Behandlar…",
+    "searchAccount": "Sök konton...",
+    "searchMailbox": "Sök brevlådor...",
+    "selectAccount": "Välj ett konto",
+    "selectAccountFirst": "Välj ett konto först.",
+    "selectMailbox": "Välj en brevlåda...",
+    "source": "källa",
+    "startImport": "Importera",
+    "successCount": "{{count}} importerade",
+    "target": "1. Välj målkonto",
+    "title": "Import",
+    "uploading": "Laddar upp…",
+    "uploadingFile": "Laddar upp fil",
+    "willImportTo": "Kommer att importeras till"
+  },
   "mail": {
     "account": "Konto",
     "attachments": "Bilagor",

web/src/locales/zh-tw.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "請使用正確的憑證登入，以存取此資源。",
     "unauthorizedTitle": "無權存取"
   },
+  "import": {
+    "account": "帳戶",
+    "chooseFiles": "3. 選擇檔案",
+    "completed": "匯入完成",
+    "description": "將郵件檔案匯入至本地帳戶 (NoSync)。大檔案請使用 CLI 命令行工具。",
+    "detectedFolder": "已識別",
+    "detectedFrom": "識別自",
+    "dropHere": "將 .eml / .mbox 檔案拖曳到此處",
+    "failed": "匯入失敗",
+    "failedCount": "{{count}} 個失敗",
+    "failedDetails": "失敗詳情",
+    "folder": "資料夾",
+    "folderMethod": "2. 選擇資料夾比對策略",
+    "folderMethodDesc": "如何確定匯入 Target 郵件資料夾？",
+    "importHistory": "匯入歷史",
+    "limits": "限制：EML 100 MB · MBOX 1 GB。超過限制請使用 CLI。",
+    "modeCustom": "指定自訂資料夾名稱",
+    "modeCustomDesc": "手動輸入目標郵件資料夾的名稱。",
+    "modeExisting": "從現有郵箱中選擇",
+    "modeExistingDesc": "選擇該帳戶中已存在的郵箱資料夾。",
+    "modeHeader": "從郵件標頭自動識別",
+    "modeHeaderDesc": "讀取檔案中的 X-Gmail-Labels / X-Bichon-Metadata 標籤，未識別時預設使用檔案名稱。",
+    "noAccountFound": "未找到相關帳戶。",
+    "noFileYet": "尚未選擇任何檔案",
+    "noMailboxFound": "未找到郵箱。",
+    "noMailboxes": "該帳戶下未找到任何郵箱。",
+    "orClick": "或點擊瀏覽檔案",
+    "processed": "已處理 {{current}} / {{total}}",
+    "processing": "正在處理…",
+    "searchAccount": "搜尋帳戶...",
+    "searchMailbox": "搜尋郵箱...",
+    "selectAccount": "選擇帳戶",
+    "selectAccountFirst": "請先選擇一個帳戶。",
+    "selectMailbox": "選擇郵箱...",
+    "source": "來源",
+    "startImport": "開始匯入",
+    "successCount": "已成功匯入 {{count}} 封",
+    "target": "1. 選擇目標帳戶",
+    "title": "匯入郵件",
+    "uploading": "正在上傳…",
+    "uploadingFile": "正在上傳檔案",
+    "willImportTo": "將匯入至"
+  },
   "mail": {
     "account": "帳號",
     "attachments": "附件",

web/src/locales/zh.json

@@ -589,6 +589,49 @@
     "unauthorizedDesc": "请使用适当的凭据登录以访问此资源。",
     "unauthorizedTitle": "未授权访问"
   },
+  "import": {
+    "account": "账户",
+    "chooseFiles": "3. 选择文件",
+    "completed": "导入完成",
+    "description": "将邮件文件导入至本地账户 (NoSync)。大文件请使用 CLI 命令行工具。",
+    "detectedFolder": "已识别",
+    "detectedFrom": "识别自",
+    "dropHere": "将 .eml / .mbox 文件拖拽到此处",
+    "failed": "导入失败",
+    "failedCount": "{{count}} 个失败",
+    "failedDetails": "失败详情",
+    "folder": "文件夹",
+    "folderMethod": "2. 选择文件夹匹配策略",
+    "folderMethodDesc": "如何确定导入的目标邮件文件夹？",
+    "importHistory": "导入历史",
+    "limits": "限制：EML 100 MB · MBOX 1 GB。超过限制请使用 CLI。",
+    "modeCustom": "指定自定义文件夹名称",
+    "modeCustomDesc": "手动输入目标邮件文件夹的名称。",
+    "modeExisting": "从现有邮箱中选择",
+    "modeExistingDesc": "选择该账户中已存在的邮箱文件夹。",
+    "modeHeader": "从邮件标头自动识别",
+    "modeHeaderDesc": "读取文件中的 X-Gmail-Labels / X-Bichon-Metadata 标签，未识别时默认使用文件名。",
+    "noAccountFound": "未找到相关账户。",
+    "noFileYet": "尚未选择任何文件",
+    "noMailboxFound": "未找到邮箱。",
+    "noMailboxes": "该账户下未找到任何邮箱。",
+    "orClick": "或点击浏览文件",
+    "processed": "已处理 {{current}} / {{total}}",
+    "processing": "正在处理…",
+    "searchAccount": "搜索账户...",
+    "searchMailbox": "搜索邮箱...",
+    "selectAccount": "选择账户",
+    "selectAccountFirst": "请先选择一个账户。",
+    "selectMailbox": "选择邮箱...",
+    "source": "来源",
+    "startImport": "开始导入",
+    "successCount": "已成功导入 {{count}} 封",
+    "target": "1. 选择目标账户",
+    "title": "导入邮件",
+    "uploading": "正在上传…",
+    "uploadingFile": "正在上传文件",
+    "willImportTo": "将导入至"
+  },
   "mail": {
     "account": "账户",
     "attachments": "附件",

web/src/routeTree.gen.ts

@@ -18,6 +18,7 @@ import { Route as AuthenticatedIndexImport } from './routes/_authenticated/index
 import { Route as authSignInImport } from './routes/(auth)/sign-in'
 import { Route as auth500Import } from './routes/(auth)/500'
 import { Route as AuthenticatedSearchIndexImport } from './routes/_authenticated/search/index'
+import { Route as AuthenticatedImportIndexImport } from './routes/_authenticated/import/index'
 import { Route as AuthenticatedAttachmentIndexImport } from './routes/_authenticated/attachment/index'
 
 // Create Virtual Routes
@@ -221,6 +222,12 @@ const AuthenticatedSearchIndexRoute = AuthenticatedSearchIndexImport.update({
   getParentRoute: () => AuthenticatedRouteRoute,
 } as any)
 
+const AuthenticatedImportIndexRoute = AuthenticatedImportIndexImport.update({
+  id: '/import/',
+  path: '/import/',
+  getParentRoute: () => AuthenticatedRouteRoute,
+} as any)
+
 const AuthenticatedAttachmentIndexRoute =
   AuthenticatedAttachmentIndexImport.update({
     id: '/attachment/',
@@ -454,6 +461,13 @@ declare module '@tanstack/react-router' {
       preLoaderRoute: typeof AuthenticatedAttachmentIndexImport
       parentRoute: typeof AuthenticatedRouteImport
     }
+    '/_authenticated/import/': {
+      id: '/_authenticated/import/'
+      path: '/import'
+      fullPath: '/import'
+      preLoaderRoute: typeof AuthenticatedImportIndexImport
+      parentRoute: typeof AuthenticatedRouteImport
+    }
     '/_authenticated/search/': {
       id: '/_authenticated/search/'
       path: '/search'
@@ -561,6 +575,7 @@ interface AuthenticatedRouteRouteChildren {
   AuthenticatedUsersRouteLazyRoute: typeof AuthenticatedUsersRouteLazyRouteWithChildren
   AuthenticatedIndexRoute: typeof AuthenticatedIndexRoute
   AuthenticatedAttachmentIndexRoute: typeof AuthenticatedAttachmentIndexRoute
+  AuthenticatedImportIndexRoute: typeof AuthenticatedImportIndexRoute
   AuthenticatedSearchIndexRoute: typeof AuthenticatedSearchIndexRoute
   AuthenticatedAccountsIndexLazyRoute: typeof AuthenticatedAccountsIndexLazyRoute
   AuthenticatedApiDocsIndexLazyRoute: typeof AuthenticatedApiDocsIndexLazyRoute
@@ -575,6 +590,7 @@ const AuthenticatedRouteRouteChildren: AuthenticatedRouteRouteChildren = {
     AuthenticatedUsersRouteLazyRouteWithChildren,
   AuthenticatedIndexRoute: AuthenticatedIndexRoute,
   AuthenticatedAttachmentIndexRoute: AuthenticatedAttachmentIndexRoute,
+  AuthenticatedImportIndexRoute: AuthenticatedImportIndexRoute,
   AuthenticatedSearchIndexRoute: AuthenticatedSearchIndexRoute,
   AuthenticatedAccountsIndexLazyRoute: AuthenticatedAccountsIndexLazyRoute,
   AuthenticatedApiDocsIndexLazyRoute: AuthenticatedApiDocsIndexLazyRoute,
@@ -606,6 +622,7 @@ export interface FileRoutesByFullPath {
   '/users/api-tokens': typeof AuthenticatedUsersApiTokensLazyRoute
   '/users/roles': typeof AuthenticatedUsersRolesLazyRoute
   '/attachment': typeof AuthenticatedAttachmentIndexRoute
+  '/import': typeof AuthenticatedImportIndexRoute
   '/search': typeof AuthenticatedSearchIndexRoute
   '/accounts': typeof AuthenticatedAccountsIndexLazyRoute
   '/api-docs': typeof AuthenticatedApiDocsIndexLazyRoute
@@ -632,6 +649,7 @@ export interface FileRoutesByTo {
   '/users/api-tokens': typeof AuthenticatedUsersApiTokensLazyRoute
   '/users/roles': typeof AuthenticatedUsersRolesLazyRoute
   '/attachment': typeof AuthenticatedAttachmentIndexRoute
+  '/import': typeof AuthenticatedImportIndexRoute
   '/search': typeof AuthenticatedSearchIndexRoute
   '/accounts': typeof AuthenticatedAccountsIndexLazyRoute
   '/api-docs': typeof AuthenticatedApiDocsIndexLazyRoute
@@ -663,6 +681,7 @@ export interface FileRoutesById {
   '/_authenticated/users/api-tokens': typeof AuthenticatedUsersApiTokensLazyRoute
   '/_authenticated/users/roles': typeof AuthenticatedUsersRolesLazyRoute
   '/_authenticated/attachment/': typeof AuthenticatedAttachmentIndexRoute
+  '/_authenticated/import/': typeof AuthenticatedImportIndexRoute
   '/_authenticated/search/': typeof AuthenticatedSearchIndexRoute
   '/_authenticated/accounts/': typeof AuthenticatedAccountsIndexLazyRoute
   '/_authenticated/api-docs/': typeof AuthenticatedApiDocsIndexLazyRoute
@@ -694,6 +713,7 @@ export interface FileRouteTypes {
     | '/users/api-tokens'
     | '/users/roles'
     | '/attachment'
+    | '/import'
     | '/search'
     | '/accounts'
     | '/api-docs'
@@ -719,6 +739,7 @@ export interface FileRouteTypes {
     | '/users/api-tokens'
     | '/users/roles'
     | '/attachment'
+    | '/import'
     | '/search'
     | '/accounts'
     | '/api-docs'
@@ -748,6 +769,7 @@ export interface FileRouteTypes {
     | '/_authenticated/users/api-tokens'
     | '/_authenticated/users/roles'
     | '/_authenticated/attachment/'
+    | '/_authenticated/import/'
     | '/_authenticated/search/'
     | '/_authenticated/accounts/'
     | '/_authenticated/api-docs/'
@@ -807,6 +829,7 @@ export const routeTree = rootRoute
         "/_authenticated/users",
         "/_authenticated/",
         "/_authenticated/attachment/",
+        "/_authenticated/import/",
         "/_authenticated/search/",
         "/_authenticated/accounts/",
         "/_authenticated/api-docs/",
@@ -897,6 +920,10 @@ export const routeTree = rootRoute
       "filePath": "_authenticated/attachment/index.tsx",
       "parent": "/_authenticated"
     },
+    "/_authenticated/import/": {
+      "filePath": "_authenticated/import/index.tsx",
+      "parent": "/_authenticated"
+    },
     "/_authenticated/search/": {
       "filePath": "_authenticated/search/index.tsx",
       "parent": "/_authenticated"

web/src/routes/_authenticated/import/index.tsx

@@ -0,0 +1,6 @@
+import { createFileRoute } from '@tanstack/react-router'
+import ImportPage from '@/features/import'
+
+export const Route = createFileRoute('/_authenticated/import/')({
+  component: ImportPage,
+})