v1.2.0 + v1.3.0: Localization, About dialog, TOTP/2FA, stability improvements

v1.2.0:
- GUI localization (EN/RU/ZH) with language switcher and persistent selection
- About dialog (ⓘ) with app info, features, quick start guide
- core/i18n.py — internationalization module with t() function
- All GUI components translated via t() keys

v1.3.0:
- TOTP/2FA tab — Google Authenticator compatible codes with live 30s countdown,
  one-click copy, per-server secret management
- core/totp.py — TOTP module (pyotp, RFC 6238)
- core/logger.py — rotating file logger (5MB, 3 backups)
- Stronger Fernet encryption key with automatic migration from old key
- Thread-safe server store with locks, atomic writes, auto-restore on corruption
- Parallel status checks via ThreadPoolExecutor (up to 10 concurrent)
- SSH client: explicit channel cleanup, Unix key permissions
- Server dialog: port validation (1-65535), TOTP secret field
- Language change preserves active tab and server selection
- pyotp dependency added

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

gui/tabs/files_tab.py

@@ -7,6 +7,7 @@ import threading
 import customtkinter as ctk
 from tkinter import filedialog
 from core.ssh_client import SSHClientWrapper
+from core.i18n import t
 
 
 class FilesTab(ctk.CTkFrame):
@@ -16,48 +17,54 @@ class FilesTab(ctk.CTkFrame):
         self._current_alias: str | None = None
 
         # Upload section
-        upload_label = ctk.CTkLabel(self, text="Upload", font=ctk.CTkFont(size=14, weight="bold"), anchor="w")
-        upload_label.pack(fill="x", padx=15, pady=(15, 5))
+        self.upload_label = ctk.CTkLabel(self, text=t("upload"), font=ctk.CTkFont(size=14, weight="bold"), anchor="w")
+        self.upload_label.pack(fill="x", padx=15, pady=(15, 5))
 
         upload_frame = ctk.CTkFrame(self, fg_color="transparent")
         upload_frame.pack(fill="x", padx=15, pady=(0, 5))
 
-        ctk.CTkLabel(upload_frame, text="Local:", width=60, anchor="w").pack(side="left")
-        self.upload_local = ctk.CTkEntry(upload_frame, placeholder_text="/path/to/local/file")
+        self.upload_local_label = ctk.CTkLabel(upload_frame, text=t("local"), width=60, anchor="w")
+        self.upload_local_label.pack(side="left")
+        self.upload_local = ctk.CTkEntry(upload_frame, placeholder_text=t("placeholder_local_file"))
         self.upload_local.pack(side="left", fill="x", expand=True, padx=5)
-        ctk.CTkButton(upload_frame, text="Browse", width=70, command=self._browse_upload).pack(side="right")
+        self.browse_upload_btn = ctk.CTkButton(upload_frame, text=t("browse"), width=70, command=self._browse_upload)
+        self.browse_upload_btn.pack(side="right")
 
         upload_remote_frame = ctk.CTkFrame(self, fg_color="transparent")
         upload_remote_frame.pack(fill="x", padx=15, pady=(0, 5))
 
-        ctk.CTkLabel(upload_remote_frame, text="Remote:", width=60, anchor="w").pack(side="left")
-        self.upload_remote = ctk.CTkEntry(upload_remote_frame, placeholder_text="/remote/path/file")
+        self.upload_remote_label = ctk.CTkLabel(upload_remote_frame, text=t("remote"), width=60, anchor="w")
+        self.upload_remote_label.pack(side="left")
+        self.upload_remote = ctk.CTkEntry(upload_remote_frame, placeholder_text=t("placeholder_remote_file"))
         self.upload_remote.pack(side="left", fill="x", expand=True, padx=5)
-        self.upload_btn = ctk.CTkButton(upload_remote_frame, text="Upload", width=70, command=self._upload)
+        self.upload_btn = ctk.CTkButton(upload_remote_frame, text=t("upload"), width=70, command=self._upload)
         self.upload_btn.pack(side="right")
 
         # Separator
         ctk.CTkFrame(self, height=2, fg_color="gray40").pack(fill="x", padx=15, pady=10)
 
         # Download section
-        download_label = ctk.CTkLabel(self, text="Download", font=ctk.CTkFont(size=14, weight="bold"), anchor="w")
-        download_label.pack(fill="x", padx=15, pady=(5, 5))
+        self.download_label = ctk.CTkLabel(self, text=t("download"), font=ctk.CTkFont(size=14, weight="bold"), anchor="w")
+        self.download_label.pack(fill="x", padx=15, pady=(5, 5))
 
         download_remote_frame = ctk.CTkFrame(self, fg_color="transparent")
         download_remote_frame.pack(fill="x", padx=15, pady=(0, 5))
 
-        ctk.CTkLabel(download_remote_frame, text="Remote:", width=60, anchor="w").pack(side="left")
-        self.download_remote = ctk.CTkEntry(download_remote_frame, placeholder_text="/remote/path/file")
+        self.download_remote_label = ctk.CTkLabel(download_remote_frame, text=t("remote"), width=60, anchor="w")
+        self.download_remote_label.pack(side="left")
+        self.download_remote = ctk.CTkEntry(download_remote_frame, placeholder_text=t("placeholder_remote_file"))
         self.download_remote.pack(side="left", fill="x", expand=True, padx=5)
 
         download_local_frame = ctk.CTkFrame(self, fg_color="transparent")
         download_local_frame.pack(fill="x", padx=15, pady=(0, 5))
 
-        ctk.CTkLabel(download_local_frame, text="Local:", width=60, anchor="w").pack(side="left")
-        self.download_local = ctk.CTkEntry(download_local_frame, placeholder_text="/path/to/save")
+        self.download_local_label = ctk.CTkLabel(download_local_frame, text=t("local"), width=60, anchor="w")
+        self.download_local_label.pack(side="left")
+        self.download_local = ctk.CTkEntry(download_local_frame, placeholder_text=t("placeholder_save_path"))
         self.download_local.pack(side="left", fill="x", expand=True, padx=5)
-        ctk.CTkButton(download_local_frame, text="Browse", width=70, command=self._browse_download).pack(side="left", padx=(5, 0))
-        self.download_btn = ctk.CTkButton(download_local_frame, text="Download", width=80, command=self._download)
+        self.browse_download_btn = ctk.CTkButton(download_local_frame, text=t("browse"), width=70, command=self._browse_download)
+        self.browse_download_btn.pack(side="left", padx=(5, 0))
+        self.download_btn = ctk.CTkButton(download_local_frame, text=t("download"), width=80, command=self._download)
         self.download_btn.pack(side="right")
 
         # Progress
@@ -94,15 +101,15 @@ class FilesTab(ctk.CTkFrame):
 
     def _upload(self):
         if not self._current_alias:
-            self._log_msg("[!] No server selected")
+            self._log_msg(t("no_server_selected"))
             return
         local = self.upload_local.get().strip()
         remote = self.upload_remote.get().strip()
         if not local or not remote:
-            self._log_msg("[!] Both paths required")
+            self._log_msg(t("both_paths_required"))
             return
         if not os.path.exists(local):
-            self._log_msg(f"[!] File not found: {local}")
+            self._log_msg(t("file_not_found").format(path=local))
             return
 
         server = self.store.get_server(self._current_alias)
@@ -121,7 +128,7 @@ class FilesTab(ctk.CTkFrame):
             try:
                 wrapper = SSHClientWrapper(server, self.store.get_ssh_key_path())
                 wrapper.upload(local, remote, progress_cb=_progress)
-                self.after(0, lambda: self._log_msg(f"OK: {local} -> {self._current_alias}:{remote}"))
+                self.after(0, lambda: self._log_msg(t("upload_ok").format(local=local, alias=self._current_alias, remote=remote)))
             except Exception as e:
                 self.after(0, lambda: self._log_msg(f"[ERROR] {e}"))
             finally:
@@ -131,12 +138,12 @@ class FilesTab(ctk.CTkFrame):
 
     def _download(self):
         if not self._current_alias:
-            self._log_msg("[!] No server selected")
+            self._log_msg(t("no_server_selected"))
             return
         remote = self.download_remote.get().strip()
         local = self.download_local.get().strip()
         if not remote or not local:
-            self._log_msg("[!] Both paths required")
+            self._log_msg(t("both_paths_required"))
             return
 
         server = self.store.get_server(self._current_alias)
@@ -154,7 +161,7 @@ class FilesTab(ctk.CTkFrame):
             try:
                 wrapper = SSHClientWrapper(server, self.store.get_ssh_key_path())
                 wrapper.download(remote, local, progress_cb=_progress)
-                self.after(0, lambda: self._log_msg(f"OK: {self._current_alias}:{remote} -> {local}"))
+                self.after(0, lambda: self._log_msg(t("download_ok").format(alias=self._current_alias, remote=remote, local=local)))
             except Exception as e:
                 self.after(0, lambda: self._log_msg(f"[ERROR] {e}"))
             finally:

gui/tabs/info_tab.py

@@ -3,9 +3,22 @@ Info tab — display server details, edit button.
 """
 
 import customtkinter as ctk
+from core.i18n import t
 
 
 class InfoTab(ctk.CTkFrame):
+    # Map field keys to i18n keys
+    _FIELD_KEYS = ["alias", "ip", "port", "user", "type", "notes", "status"]
+    _FIELD_I18N = {
+        "alias": "info_alias",
+        "ip": "info_ip",
+        "port": "info_port",
+        "user": "info_user",
+        "type": "info_type",
+        "notes": "info_notes",
+        "status": "info_status",
+    }
+
     def __init__(self, master, store, edit_callback=None):
         super().__init__(master, fg_color="transparent")
         self.store = store
@@ -13,7 +26,7 @@ class InfoTab(ctk.CTkFrame):
         self._current_alias: str | None = None
 
         # Header
-        self.header = ctk.CTkLabel(self, text="No server selected", font=ctk.CTkFont(size=20, weight="bold"))
+        self.header = ctk.CTkLabel(self, text=t("no_server_selected_info"), font=ctk.CTkFont(size=20, weight="bold"))
         self.header.pack(padx=20, pady=(20, 10))
 
         # Info card
@@ -21,17 +34,20 @@ class InfoTab(ctk.CTkFrame):
         self.card.pack(fill="x", padx=20, pady=10)
 
         self._fields: dict[str, ctk.CTkLabel] = {}
-        for label in ["Alias", "IP", "Port", "User", "Type", "Notes", "Status"]:
+        self._field_labels: dict[str, ctk.CTkLabel] = {}
+        for key in self._FIELD_KEYS:
             row = ctk.CTkFrame(self.card, fg_color="transparent")
             row.pack(fill="x", padx=15, pady=4)
-            ctk.CTkLabel(row, text=f"{label}:", width=80, anchor="w",
-                        font=ctk.CTkFont(size=12), text_color="#9ca3af").pack(side="left")
+            label = ctk.CTkLabel(row, text=t(self._FIELD_I18N[key]), width=80, anchor="w",
+                        font=ctk.CTkFont(size=12), text_color="#9ca3af")
+            label.pack(side="left")
             val = ctk.CTkLabel(row, text="-", anchor="w", font=ctk.CTkFont(size=13))
             val.pack(side="left", fill="x", expand=True)
-            self._fields[label] = val
+            self._field_labels[key] = label
+            self._fields[key] = val
 
         # Edit button
-        self.edit_btn = ctk.CTkButton(self, text="Edit Server", command=self._on_edit)
+        self.edit_btn = ctk.CTkButton(self, text=t("edit_server_btn"), command=self._on_edit)
         self.edit_btn.pack(pady=15)
 
     def set_server(self, alias: str | None):
@@ -40,7 +56,7 @@ class InfoTab(ctk.CTkFrame):
 
     def refresh(self):
         if not self._current_alias:
-            self.header.configure(text="No server selected")
+            self.header.configure(text=t("no_server_selected_info"))
             for v in self._fields.values():
                 v.configure(text="-")
             return
@@ -50,16 +66,16 @@ class InfoTab(ctk.CTkFrame):
             return
 
         self.header.configure(text=server["alias"])
-        self._fields["Alias"].configure(text=server.get("alias", "-"))
-        self._fields["IP"].configure(text=server.get("ip", "-"))
-        self._fields["Port"].configure(text=str(server.get("port", 22)))
-        self._fields["User"].configure(text=server.get("user", "root"))
-        self._fields["Type"].configure(text=server.get("type", "ssh").upper())
-        self._fields["Notes"].configure(text=server.get("notes", "-") or "-")
+        self._fields["alias"].configure(text=server.get("alias", "-"))
+        self._fields["ip"].configure(text=server.get("ip", "-"))
+        self._fields["port"].configure(text=str(server.get("port", 22)))
+        self._fields["user"].configure(text=server.get("user", "root"))
+        self._fields["type"].configure(text=server.get("type", "ssh").upper())
+        self._fields["notes"].configure(text=server.get("notes", "-") or "-")
 
         status = self.store.get_status(self._current_alias)
         color = {"online": "#22c55e", "offline": "#ef4444"}.get(status, "#9ca3af")
-        self._fields["Status"].configure(text=status.upper(), text_color=color)
+        self._fields["status"].configure(text=status.upper(), text_color=color)
 
     def _on_edit(self):
         if self.edit_callback and self._current_alias:

gui/tabs/keys_tab.py

@@ -6,6 +6,7 @@ import os
 import threading
 import customtkinter as ctk
 from core.ssh_client import SSHClientWrapper
+from core.i18n import t
 
 
 class KeysTab(ctk.CTkFrame):
@@ -15,7 +16,8 @@ class KeysTab(ctk.CTkFrame):
         self._current_alias: str | None = None
 
         # Key info
-        ctk.CTkLabel(self, text="SSH Key", font=ctk.CTkFont(size=16, weight="bold"), anchor="w").pack(fill="x", padx=15, pady=(15, 5))
+        self.key_title = ctk.CTkLabel(self, text=t("ssh_key"), font=ctk.CTkFont(size=16, weight="bold"), anchor="w")
+        self.key_title.pack(fill="x", padx=15, pady=(15, 5))
 
         self.key_path_label = ctk.CTkLabel(self, text="", anchor="w", text_color="#9ca3af")
         self.key_path_label.pack(fill="x", padx=15)
@@ -27,13 +29,13 @@ class KeysTab(ctk.CTkFrame):
         btn_frame = ctk.CTkFrame(self, fg_color="transparent")
         btn_frame.pack(fill="x", padx=15, pady=5)
 
-        self.gen_btn = ctk.CTkButton(btn_frame, text="Generate Key", command=self._generate)
+        self.gen_btn = ctk.CTkButton(btn_frame, text=t("generate_key"), command=self._generate)
         self.gen_btn.pack(side="left", padx=(0, 10))
 
-        self.install_btn = ctk.CTkButton(btn_frame, text="Install on Server", fg_color="#22c55e", hover_color="#16a34a", command=self._install)
+        self.install_btn = ctk.CTkButton(btn_frame, text=t("install_on_server"), fg_color="#22c55e", hover_color="#16a34a", command=self._install)
         self.install_btn.pack(side="left")
 
-        self.copy_btn = ctk.CTkButton(btn_frame, text="Copy Public Key", fg_color="#6b7280", command=self._copy_key)
+        self.copy_btn = ctk.CTkButton(btn_frame, text=t("copy_public_key"), fg_color="#6b7280", command=self._copy_key)
         self.copy_btn.pack(side="right")
 
         # Status log
@@ -48,7 +50,7 @@ class KeysTab(ctk.CTkFrame):
     def _refresh_key_info(self):
         key_path = self.store.get_ssh_key_path()
         pub_path = key_path + ".pub"
-        self.key_path_label.configure(text=f"Path: {key_path}")
+        self.key_path_label.configure(text=t("key_path").format(path=key_path))
 
         self.pub_key_box.configure(state="normal")
         self.pub_key_box.delete("1.0", "end")
@@ -57,10 +59,10 @@ class KeysTab(ctk.CTkFrame):
             with open(pub_path, "r") as f:
                 pub_key = f.read().strip()
             self.pub_key_box.insert("1.0", pub_key)
-            self.gen_btn.configure(state="disabled", text="Key exists")
+            self.gen_btn.configure(state="disabled", text=t("key_exists"))
         else:
-            self.pub_key_box.insert("1.0", "No key found. Click 'Generate Key' to create one.")
-            self.gen_btn.configure(state="normal", text="Generate Key")
+            self.pub_key_box.insert("1.0", t("no_key_found"))
+            self.gen_btn.configure(state="normal", text=t("generate_key"))
 
         self.pub_key_box.configure(state="disabled")
 
@@ -82,14 +84,14 @@ class KeysTab(ctk.CTkFrame):
 
     def _install(self):
         if not self._current_alias:
-            self._log("[!] No server selected")
+            self._log(t("no_server_selected"))
             return
 
         server = self.store.get_server(self._current_alias)
         if not server:
             return
 
-        self.install_btn.configure(state="disabled", text="Installing...")
+        self.install_btn.configure(state="disabled", text=t("installing"))
 
         def _do():
             try:
@@ -99,7 +101,7 @@ class KeysTab(ctk.CTkFrame):
             except Exception as e:
                 self.after(0, lambda: self._log(f"[ERROR] {e}"))
             finally:
-                self.after(0, lambda: self.install_btn.configure(state="normal", text="Install on Server"))
+                self.after(0, lambda: self.install_btn.configure(state="normal", text=t("install_on_server")))
 
         threading.Thread(target=_do, daemon=True).start()
 
@@ -111,6 +113,6 @@ class KeysTab(ctk.CTkFrame):
                 pub_key = f.read().strip()
             self.clipboard_clear()
             self.clipboard_append(pub_key)
-            self._log("Public key copied to clipboard")
+            self._log(t("key_copied"))
         else:
-            self._log("[!] No public key to copy")
+            self._log(t("no_public_key"))

gui/tabs/setup_tab.py

@@ -1,10 +1,14 @@
 """
 Setup tab — one-click installation for Claude Code integration.
+Includes configuration path management and backup/restore.
 """
 
+import os
 import threading
+from tkinter import filedialog, messagebox
 import customtkinter as ctk
 from core.claude_setup import check_status, install_all, install_ssh_script, install_skill, generate_ssh_key
+from core.i18n import t
 
 
 class SetupTab(ctk.CTkFrame):
@@ -13,50 +17,54 @@ class SetupTab(ctk.CTkFrame):
         self.store = store
 
         # Header
-        ctk.CTkLabel(
-            self, text="Claude Code Integration",
+        self.header_label = ctk.CTkLabel(
+            self, text=t("claude_integration"),
             font=ctk.CTkFont(size=20, weight="bold")
-        ).pack(padx=20, pady=(20, 5))
+        )
+        self.header_label.pack(padx=20, pady=(20, 5))
 
-        ctk.CTkLabel(
-            self,
-            text="Setup everything so Claude Code can manage your servers via /ssh skill.\n"
-                 "Both GUI and Claude Code share the same servers.json — add a server here,\n"
-                 "Claude sees it immediately.",
+        self.desc_label = ctk.CTkLabel(
+            self, text=t("claude_desc"),
             text_color="#9ca3af", justify="center"
-        ).pack(padx=20, pady=(0, 15))
+        )
+        self.desc_label.pack(padx=20, pady=(0, 15))
 
         # Status card
         self.status_frame = ctk.CTkFrame(self)
         self.status_frame.pack(fill="x", padx=20, pady=10)
 
-        ctk.CTkLabel(
-            self.status_frame, text="Status",
+        self.status_title = ctk.CTkLabel(
+            self.status_frame, text=t("status"),
             font=ctk.CTkFont(size=14, weight="bold"), anchor="w"
-        ).pack(fill="x", padx=15, pady=(10, 5))
+        )
+        self.status_title.pack(fill="x", padx=15, pady=(10, 5))
 
         self._status_labels: dict[str, ctk.CTkLabel] = {}
+        self._status_text_labels: dict[str, ctk.CTkLabel] = {}
         status_items = [
-            ("shared_dir", "Shared config dir (~/.server-connections)"),
-            ("servers_json", "servers.json"),
-            ("ssh_script", "ssh.py (CLI tool)"),
-            ("skill_installed", "/ssh skill for Claude Code"),
-            ("ssh_key_exists", "SSH key (ed25519)"),
+            ("shared_dir", "status_shared_dir"),
+            ("servers_json", "status_servers_json"),
+            ("ssh_script", "status_ssh_script"),
+            ("encryption", "status_encryption"),
+            ("skill_installed", "status_skill"),
+            ("ssh_key_exists", "status_ssh_key"),
         ]
-        for key, label in status_items:
+        for key, i18n_key in status_items:
             row = ctk.CTkFrame(self.status_frame, fg_color="transparent")
             row.pack(fill="x", padx=15, pady=2)
             indicator = ctk.CTkLabel(row, text="\u25cf", width=20, text_color="#6b7280")
             indicator.pack(side="left")
-            ctk.CTkLabel(row, text=label, anchor="w").pack(side="left", fill="x", expand=True)
+            text_label = ctk.CTkLabel(row, text=t(i18n_key), anchor="w")
+            text_label.pack(side="left", fill="x", expand=True)
             self._status_labels[key] = indicator
+            self._status_text_labels[key] = (text_label, i18n_key)
 
         # Buttons
         btn_frame = ctk.CTkFrame(self, fg_color="transparent")
         btn_frame.pack(fill="x", padx=20, pady=15)
 
         self.install_all_btn = ctk.CTkButton(
-            btn_frame, text="Install Everything",
+            btn_frame, text=t("install_everything"),
             font=ctk.CTkFont(size=14, weight="bold"),
             height=40, fg_color="#22c55e", hover_color="#16a34a",
             command=self._install_all
@@ -67,14 +75,71 @@ class SetupTab(ctk.CTkFrame):
         ind_frame = ctk.CTkFrame(btn_frame, fg_color="transparent")
         ind_frame.pack(fill="x")
 
-        ctk.CTkButton(ind_frame, text="ssh.py", width=100, fg_color="#6b7280",
-                      command=self._install_script).pack(side="left", padx=(0, 5))
-        ctk.CTkButton(ind_frame, text="/ssh skill", width=100, fg_color="#6b7280",
-                      command=self._install_skill).pack(side="left", padx=5)
-        ctk.CTkButton(ind_frame, text="SSH key", width=100, fg_color="#6b7280",
-                      command=self._gen_key).pack(side="left", padx=5)
-        ctk.CTkButton(ind_frame, text="Refresh", width=80, fg_color="#3b82f6",
-                      command=self._refresh_status).pack(side="right")
+        self.ssh_py_btn = ctk.CTkButton(ind_frame, text=t("install_ssh_py"), width=100, fg_color="#6b7280",
+                      command=self._install_script)
+        self.ssh_py_btn.pack(side="left", padx=(0, 5))
+        self.skill_btn = ctk.CTkButton(ind_frame, text=t("install_skill"), width=100, fg_color="#6b7280",
+                      command=self._install_skill)
+        self.skill_btn.pack(side="left", padx=5)
+        self.ssh_key_btn = ctk.CTkButton(ind_frame, text=t("install_ssh_key"), width=100, fg_color="#6b7280",
+                      command=self._gen_key)
+        self.ssh_key_btn.pack(side="left", padx=5)
+        self.refresh_btn = ctk.CTkButton(ind_frame, text=t("refresh"), width=80, fg_color="#3b82f6",
+                      command=self._refresh_status)
+        self.refresh_btn.pack(side="right")
+
+        # ── Configuration section ─────────────────────
+        config_frame = ctk.CTkFrame(self)
+        config_frame.pack(fill="x", padx=20, pady=(5, 5))
+
+        self.config_title = ctk.CTkLabel(
+            config_frame, text=t("configuration"),
+            font=ctk.CTkFont(size=14, weight="bold"), anchor="w"
+        )
+        self.config_title.pack(fill="x", padx=15, pady=(10, 5))
+
+        # Config path row
+        path_row = ctk.CTkFrame(config_frame, fg_color="transparent")
+        path_row.pack(fill="x", padx=15, pady=5)
+
+        self.config_label = ctk.CTkLabel(path_row, text=t("config_label"), anchor="w", width=60)
+        self.config_label.pack(side="left")
+        self._path_label = ctk.CTkLabel(
+            path_row, text=store.get_config_path(),
+            anchor="w", text_color="#9ca3af",
+            font=ctk.CTkFont(family="Consolas", size=11)
+        )
+        self._path_label.pack(side="left", fill="x", expand=True, padx=(5, 10))
+        self.change_path_btn = ctk.CTkButton(
+            path_row, text=t("change_path"), width=100, fg_color="#6b7280",
+            command=self._change_config_path
+        )
+        self.change_path_btn.pack(side="right")
+
+        # Backup row
+        backup_row = ctk.CTkFrame(config_frame, fg_color="transparent")
+        backup_row.pack(fill="x", padx=15, pady=(5, 10))
+
+        self.backup_btn = ctk.CTkButton(
+            backup_row, text=t("backup_now"), width=100, fg_color="#3b82f6",
+            command=self._backup_now
+        )
+        self.backup_btn.pack(side="left", padx=(0, 10))
+
+        self._backup_var = ctk.StringVar(value=t("select_backup"))
+        backups = store.list_backups()
+        values = backups if backups else [t("no_backups")]
+        self._backup_menu = ctk.CTkOptionMenu(
+            backup_row, variable=self._backup_var,
+            values=values, width=250
+        )
+        self._backup_menu.pack(side="left", padx=(0, 10))
+
+        self.restore_btn = ctk.CTkButton(
+            backup_row, text=t("restore"), width=80, fg_color="#ef4444", hover_color="#dc2626",
+            command=self._restore_backup
+        )
+        self.restore_btn.pack(side="left")
 
         # Log
         self.log = ctk.CTkTextbox(self, height=150, font=ctk.CTkFont(family="Consolas", size=11), state="disabled")
@@ -98,15 +163,15 @@ class SetupTab(ctk.CTkFrame):
                 label.configure(text="\u25cf", text_color="#ef4444")  # red
 
     def _install_all(self):
-        self.install_all_btn.configure(state="disabled", text="Installing...")
+        self.install_all_btn.configure(state="disabled", text=t("installing_all"))
 
         def _do():
             results = install_all()
             for msg in results:
                 self.after(0, lambda m=msg: self._log(m))
             self.after(0, self._refresh_status)
-            self.after(0, lambda: self._log("\nDone! Claude Code can now use /ssh to manage your servers."))
-            self.after(0, lambda: self.install_all_btn.configure(state="normal", text="Install Everything"))
+            self.after(0, lambda: self._log("\n" + t("install_done")))
+            self.after(0, lambda: self.install_all_btn.configure(state="normal", text=t("install_everything")))
 
         threading.Thread(target=_do, daemon=True).start()
 
@@ -124,3 +189,46 @@ class SetupTab(ctk.CTkFrame):
         msg = generate_ssh_key()
         self._log(msg)
         self._refresh_status()
+
+    # ── Configuration methods ─────────────────────────
+
+    def _change_config_path(self):
+        path = filedialog.askopenfilename(
+            title=t("select_servers_json"),
+            filetypes=[("JSON files", "*.json"), ("All files", "*.*")],
+            initialdir=os.path.dirname(self.store.get_config_path())
+        )
+        if path:
+            self.store.set_config_path(path)
+            self._path_label.configure(text=path)
+            self._log(t("config_changed").format(path=path))
+
+    def _backup_now(self):
+        try:
+            name = self.store.create_backup()
+            self._log(t("backup_created").format(name=name))
+            self._refresh_backups()
+        except Exception as e:
+            self._log(t("backup_failed").format(e=e))
+
+    def _restore_backup(self):
+        selected = self._backup_var.get()
+        if not selected or selected in (t("select_backup"), t("no_backups")):
+            self._log(t("no_backup_selected"))
+            return
+        if not messagebox.askyesno(t("restore_backup_title"), t("restore_confirm").format(name=selected)):
+            return
+        try:
+            self.store.restore_backup(selected)
+            self._log(t("restored").format(name=selected))
+        except Exception as e:
+            self._log(t("restore_failed").format(e=e))
+
+    def _refresh_backups(self):
+        backups = self.store.list_backups()
+        if backups:
+            self._backup_menu.configure(values=backups)
+            self._backup_var.set(backups[0])
+        else:
+            self._backup_menu.configure(values=[t("no_backups")])
+            self._backup_var.set(t("no_backups"))

gui/tabs/terminal_tab.py

@@ -5,6 +5,7 @@ Terminal tab — command input + output display.
 import threading
 import customtkinter as ctk
 from core.ssh_client import SSHClientWrapper
+from core.i18n import t
 
 
 class TerminalTab(ctk.CTkFrame):
@@ -22,17 +23,17 @@ class TerminalTab(ctk.CTkFrame):
         input_frame.pack(fill="x", padx=10, pady=(0, 10))
 
         self.sudo_var = ctk.BooleanVar(value=True)
-        self.sudo_check = ctk.CTkCheckBox(input_frame, text="sudo", variable=self.sudo_var, width=60)
+        self.sudo_check = ctk.CTkCheckBox(input_frame, text=t("sudo"), variable=self.sudo_var, width=60)
         self.sudo_check.pack(side="left", padx=(0, 5))
 
-        self.cmd_entry = ctk.CTkEntry(input_frame, placeholder_text="Enter command...")
+        self.cmd_entry = ctk.CTkEntry(input_frame, placeholder_text=t("enter_command"))
         self.cmd_entry.pack(side="left", fill="x", expand=True, padx=(0, 5))
         self.cmd_entry.bind("<Return>", lambda e: self._run_command())
 
-        self.run_btn = ctk.CTkButton(input_frame, text="Run", width=70, command=self._run_command)
+        self.run_btn = ctk.CTkButton(input_frame, text=t("run"), width=70, command=self._run_command)
         self.run_btn.pack(side="left", padx=(0, 5))
 
-        self.clear_btn = ctk.CTkButton(input_frame, text="Clear", width=60, fg_color="#6b7280", command=self._clear)
+        self.clear_btn = ctk.CTkButton(input_frame, text=t("clear"), width=60, fg_color="#6b7280", command=self._clear)
         self.clear_btn.pack(side="right")
 
     def set_server(self, alias: str | None):
@@ -50,7 +51,7 @@ class TerminalTab(ctk.CTkFrame):
 
     def _run_command(self):
         if not self._current_alias:
-            self._append_output("[!] No server selected\n")
+            self._append_output(t("no_server_selected") + "\n")
             return
 
         command = self.cmd_entry.get().strip()
@@ -59,7 +60,7 @@ class TerminalTab(ctk.CTkFrame):
 
         server = self.store.get_server(self._current_alias)
         if not server:
-            self._append_output(f"[!] Server '{self._current_alias}' not found\n")
+            self._append_output(t("server_not_found").format(alias=self._current_alias) + "\n")
             return
 
         self.cmd_entry.delete(0, "end")
@@ -87,13 +88,13 @@ class TerminalTab(ctk.CTkFrame):
                     if code != 0:
                         self._append_output(f"[exit code: {code}]\n")
                     self._append_output("\n")
-                    self.run_btn.configure(state="normal", text="Run")
+                    self.run_btn.configure(state="normal", text=t("run"))
 
                 self.after(0, _show)
             except Exception as e:
                 def _err():
                     self._append_output(f"[ERROR] {e}\n\n")
-                    self.run_btn.configure(state="normal", text="Run")
+                    self.run_btn.configure(state="normal", text=t("run"))
                 self.after(0, _err)
 
         threading.Thread(target=_exec, daemon=True).start()

gui/tabs/totp_tab.py

@@ -0,0 +1,285 @@
+"""
+TOTP tab — Google Authenticator compatible 2FA codes.
+Live countdown, one-click copy, per-server secrets.
+"""
+
+import threading
+import customtkinter as ctk
+from core.i18n import t
+
+
+class TOTPTab(ctk.CTkFrame):
+    def __init__(self, master, store):
+        super().__init__(master, fg_color="transparent")
+        self.store = store
+        self._current_alias: str | None = None
+        self._timer_id = None
+
+        # Title
+        self.title_label = ctk.CTkLabel(
+            self, text=t("totp_title"),
+            font=ctk.CTkFont(size=16, weight="bold"), anchor="w"
+        )
+        self.title_label.pack(fill="x", padx=15, pady=(15, 5))
+
+        # Description
+        self.desc_label = ctk.CTkLabel(
+            self, text=t("totp_desc"),
+            anchor="w", text_color="#9ca3af", wraplength=600, justify="left"
+        )
+        self.desc_label.pack(fill="x", padx=15, pady=(0, 10))
+
+        # Server name
+        self.server_label = ctk.CTkLabel(
+            self, text=t("no_server_selected"),
+            font=ctk.CTkFont(size=13), anchor="w", text_color="#6b7280"
+        )
+        self.server_label.pack(fill="x", padx=15, pady=(0, 10))
+
+        # Code display frame
+        code_frame = ctk.CTkFrame(self, fg_color="#1e1e2e", corner_radius=12)
+        code_frame.pack(fill="x", padx=15, pady=(0, 10))
+
+        self.code_label = ctk.CTkLabel(
+            code_frame, text="------",
+            font=ctk.CTkFont(family="Consolas", size=42, weight="bold"),
+            text_color="#22c55e"
+        )
+        self.code_label.pack(pady=(20, 5))
+
+        self.timer_label = ctk.CTkLabel(
+            code_frame, text="",
+            font=ctk.CTkFont(size=12), text_color="#9ca3af"
+        )
+        self.timer_label.pack(pady=(0, 5))
+
+        self.progress_bar = ctk.CTkProgressBar(code_frame, width=300, height=6)
+        self.progress_bar.pack(pady=(0, 15))
+        self.progress_bar.set(1.0)
+
+        # Copy button
+        self.copy_btn = ctk.CTkButton(
+            self, text=t("totp_copy"), width=200, height=40,
+            font=ctk.CTkFont(size=14),
+            fg_color="#22c55e", hover_color="#16a34a",
+            command=self._copy_code
+        )
+        self.copy_btn.pack(pady=(5, 15))
+
+        # Secret management section
+        secret_frame = ctk.CTkFrame(self, fg_color="transparent")
+        secret_frame.pack(fill="x", padx=15, pady=(10, 5))
+
+        ctk.CTkLabel(
+            secret_frame, text=t("totp_secret_label"),
+            font=ctk.CTkFont(size=13, weight="bold"), anchor="w"
+        ).pack(fill="x")
+
+        entry_row = ctk.CTkFrame(secret_frame, fg_color="transparent")
+        entry_row.pack(fill="x", pady=(5, 0))
+
+        self.secret_entry = ctk.CTkEntry(
+            entry_row, show="*",
+            placeholder_text=t("totp_secret_placeholder"),
+            font=ctk.CTkFont(family="Consolas", size=12)
+        )
+        self.secret_entry.pack(side="left", fill="x", expand=True, padx=(0, 5))
+
+        self.show_secret_btn = ctk.CTkButton(
+            entry_row, text=t("show"), width=70,
+            fg_color="#6b7280", hover_color="#4b5563",
+            command=self._toggle_secret
+        )
+        self.show_secret_btn.pack(side="left", padx=(0, 5))
+        self._secret_visible = False
+
+        self.save_secret_btn = ctk.CTkButton(
+            entry_row, text=t("totp_save_secret"), width=100,
+            command=self._save_secret
+        )
+        self.save_secret_btn.pack(side="left", padx=(0, 5))
+
+        self.remove_secret_btn = ctk.CTkButton(
+            entry_row, text=t("totp_remove_secret"), width=100,
+            fg_color="#ef4444", hover_color="#dc2626",
+            command=self._remove_secret
+        )
+        self.remove_secret_btn.pack(side="left")
+
+        # Generate random secret button
+        self.gen_secret_btn = ctk.CTkButton(
+            secret_frame, text=t("totp_generate_secret"), width=180,
+            fg_color="#6b7280", hover_color="#4b5563",
+            command=self._generate_secret
+        )
+        self.gen_secret_btn.pack(anchor="w", pady=(8, 0))
+
+        # Status log
+        self.status_label = ctk.CTkLabel(
+            self, text="", anchor="w", text_color="#9ca3af"
+        )
+        self.status_label.pack(fill="x", padx=15, pady=(5, 10))
+
+    def set_server(self, alias: str | None):
+        self._current_alias = alias
+        self._stop_timer()
+
+        if not alias:
+            self.server_label.configure(text=t("no_server_selected"))
+            self.code_label.configure(text="------")
+            self.timer_label.configure(text="")
+            self.progress_bar.set(1.0)
+            self.secret_entry.delete(0, "end")
+            self.status_label.configure(text="")
+            return
+
+        self.server_label.configure(text=f"🖥 {alias}")
+        server = self.store.get_server(alias)
+        if not server:
+            return
+
+        secret = server.get("totp_secret", "")
+        self.secret_entry.delete(0, "end")
+        if secret:
+            self.secret_entry.insert(0, secret)
+            self._start_timer()
+        else:
+            self.code_label.configure(text="------")
+            self.timer_label.configure(text=t("totp_no_secret"))
+            self.progress_bar.set(1.0)
+
+    def _start_timer(self):
+        self._stop_timer()
+        self._update_code()
+
+    def _stop_timer(self):
+        if self._timer_id:
+            self.after_cancel(self._timer_id)
+            self._timer_id = None
+
+    def _update_code(self):
+        if not self._current_alias:
+            return
+
+        server = self.store.get_server(self._current_alias)
+        if not server:
+            return
+
+        secret = server.get("totp_secret", "")
+        if not secret:
+            self.code_label.configure(text="------")
+            self.timer_label.configure(text=t("totp_no_secret"))
+            self.progress_bar.set(1.0)
+            return
+
+        try:
+            from core.totp import get_code_with_timer
+            data = get_code_with_timer(secret)
+            code = data["code"]
+            remaining = data["remaining"]
+            progress = data["progress"]
+
+            # Format code with space in middle: "123 456"
+            formatted = f"{code[:3]} {code[3:]}"
+            self.code_label.configure(text=formatted)
+            self.timer_label.configure(text=t("totp_remaining").format(sec=remaining))
+            self.progress_bar.set(progress)
+
+            # Color based on time remaining
+            if remaining <= 5:
+                self.code_label.configure(text_color="#ef4444")
+            elif remaining <= 10:
+                self.code_label.configure(text_color="#f59e0b")
+            else:
+                self.code_label.configure(text_color="#22c55e")
+
+        except Exception as e:
+            self.code_label.configure(text="ERROR")
+            self.timer_label.configure(text=str(e))
+
+        # Schedule next update in 1 second
+        self._timer_id = self.after(1000, self._update_code)
+
+    def _copy_code(self):
+        code_text = self.code_label.cget("text").replace(" ", "")
+        if code_text and code_text != "------" and code_text != "ERROR":
+            self.clipboard_clear()
+            self.clipboard_append(code_text)
+            self.status_label.configure(text=t("totp_copied"), text_color="#22c55e")
+            self.after(2000, lambda: self.status_label.configure(text=""))
+        else:
+            self.status_label.configure(text=t("totp_no_code"), text_color="#ef4444")
+            self.after(2000, lambda: self.status_label.configure(text=""))
+
+    def _toggle_secret(self):
+        self._secret_visible = not self._secret_visible
+        self.secret_entry.configure(show="" if self._secret_visible else "*")
+        self.show_secret_btn.configure(text=t("hide") if self._secret_visible else t("show"))
+
+    def _save_secret(self):
+        if not self._current_alias:
+            self.status_label.configure(text=t("no_server_selected"), text_color="#ef4444")
+            return
+
+        secret = self.secret_entry.get().strip()
+        if not secret:
+            self.status_label.configure(text=t("totp_secret_empty"), text_color="#ef4444")
+            self.after(2000, lambda: self.status_label.configure(text=""))
+            return
+
+        # Validate secret
+        try:
+            from core.totp import get_code
+            get_code(secret)
+        except Exception:
+            self.status_label.configure(text=t("totp_secret_invalid"), text_color="#ef4444")
+            self.after(2000, lambda: self.status_label.configure(text=""))
+            return
+
+        server = self.store.get_server(self._current_alias)
+        if server:
+            server["totp_secret"] = secret
+            self.store.update_server(self._current_alias, server)
+            self.status_label.configure(text=t("totp_secret_saved"), text_color="#22c55e")
+            self.after(2000, lambda: self.status_label.configure(text=""))
+            self._start_timer()
+
+    def _remove_secret(self):
+        if not self._current_alias:
+            return
+
+        server = self.store.get_server(self._current_alias)
+        if server and "totp_secret" in server:
+            del server["totp_secret"]
+            self.store.update_server(self._current_alias, server)
+            self.secret_entry.delete(0, "end")
+            self._stop_timer()
+            self.code_label.configure(text="------", text_color="#22c55e")
+            self.timer_label.configure(text="")
+            self.progress_bar.set(1.0)
+            self.status_label.configure(text=t("totp_secret_removed"), text_color="#9ca3af")
+            self.after(2000, lambda: self.status_label.configure(text=""))
+
+    def _generate_secret(self):
+        try:
+            from core.totp import generate_secret
+            secret = generate_secret()
+            self.secret_entry.delete(0, "end")
+            self.secret_entry.insert(0, secret)
+            self.status_label.configure(text=t("totp_secret_generated"), text_color="#22c55e")
+            self.after(2000, lambda: self.status_label.configure(text=""))
+        except Exception as e:
+            self.status_label.configure(text=f"Error: {e}", text_color="#ef4444")
+
+    def update_language(self):
+        self.title_label.configure(text=t("totp_title"))
+        self.desc_label.configure(text=t("totp_desc"))
+        self.copy_btn.configure(text=t("totp_copy"))
+        self.save_secret_btn.configure(text=t("totp_save_secret"))
+        self.remove_secret_btn.configure(text=t("totp_remove_secret"))
+        self.gen_secret_btn.configure(text=t("totp_generate_secret"))
+        self.show_secret_btn.configure(
+            text=t("hide") if self._secret_visible else t("show")
+        )
+        if not self._current_alias:
+            self.server_label.configure(text=t("no_server_selected"))