Rename onOpenFile prop to _onOpenFile and tidy formatting

Rename the unused `onOpenFile` callback to `_onOpenFile` to suppress lint warnings and clarify that it is intentionally unused.
Remove extraneous blank lines and adjust string concatenation in upload success messages for cleaner code formatting.

Rename unused onOpenFile prop and clean formatting

Renames the unused `onOpenFile` callback to `_onOpenFile` to silence lint warnings and make its intentional non‑use explicit.
Removes stray blank lines and streamlines string concatenation in upload success messages, improving code readability and consistency.

.claude/settings.local.json

@@ -1,7 +1,8 @@
 {
   "permissions": {
     "allow": [
-      "Bash(npx tsc:*)"
+      "Bash(npx tsc:*)",
+      "Bash(npm run lint:*)"
     ]
   }
 }

.github/workflows/build.yml

@@ -18,7 +18,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [macos-latest, windows-latest]
+        os: [macos-latest, windows-latest, ubuntu-latest]
     env:
       VITE_SYNC_GITHUB_CLIENT_ID: ${{ secrets.VITE_SYNC_GITHUB_CLIENT_ID }}
       VITE_SYNC_GOOGLE_CLIENT_ID: ${{ secrets.VITE_SYNC_GOOGLE_CLIENT_ID }}
@@ -58,6 +58,12 @@ jobs:
           ELECTRON_BUILDER_PUBLISH: "never"
         run: npm run pack:win
 
+      - name: Build package (Linux)
+        if: matrix.os == 'ubuntu-latest'
+        env:
+          ELECTRON_BUILDER_PUBLISH: "never"
+        run: npm run pack:linux
+
       - name: Upload artifacts
         uses: actions/upload-artifact@v4
         with:

App.tsx

@@ -1,11 +1,13 @@
 import React, { Suspense, lazy, useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { activeTabStore, useActiveTabId, useIsSftpActive, useIsTerminalLayerVisible, useIsVaultActive } from './application/state/activeTabStore';
 import { useAutoSync } from './application/state/useAutoSync';
+import { usePortForwardingAutoStart } from './application/state/usePortForwardingAutoStart';
 import { useSessionState } from './application/state/useSessionState';
 import { useSettingsState } from './application/state/useSettingsState';
 import { useUpdateCheck } from './application/state/useUpdateCheck';
 import { useVaultState } from './application/state/useVaultState';
 import { useWindowControls } from './application/state/useWindowControls';
+import { initializeFonts } from './application/state/fontStore';
 import { I18nProvider, useI18n } from './application/i18n/I18nProvider';
 import { matchesKeyBinding } from './domain/models';
 import { resolveHostAuth } from './domain/sshAuth';
@@ -23,6 +25,9 @@ import { LogView as LogViewType } from './application/state/useSessionState';
 import type { SftpView as SftpViewComponent } from './components/SftpView';
 import type { TerminalLayer as TerminalLayerComponent } from './components/TerminalLayer';
 
+// Initialize fonts eagerly at app startup
+initializeFonts();
+
 // Visibility container for VaultView - isolates isActive subscription
 const VaultViewContainer: React.FC<{ children: React.ReactNode }> = ({ children }) => {
   const isActive = useIsVaultActive();
@@ -280,6 +285,12 @@ function App({ settings }: { settings: SettingsState }) {
     }
   }, [updateState.hasUpdate, updateState.latestRelease, t, openReleasePage, dismissUpdate]);
 
+  // Auto-start port forwarding rules on app launch
+  usePortForwardingAutoStart({
+    hosts,
+    keys: keys.map((k) => ({ id: k.id, privateKey: k.privateKey })),
+  });
+
   // Debounce ref for moveFocus to prevent double-triggering when focus switches
   const lastMoveFocusTimeRef = useRef<number>(0);
   const MOVE_FOCUS_DEBOUNCE_MS = 200;

README.md

@@ -16,7 +16,7 @@
 <p align="center">
   <a href="https://github.com/binaricat/Netcatty/releases/latest"><img alt="GitHub Release" src="https://img.shields.io/github/v/release/binaricat/Netcatty?style=for-the-badge&logo=github&label=Release"></a>
   &nbsp;
-  <a href="#"><img alt="Platform" src="https://img.shields.io/badge/Platform-macOS%20%7C%20Windows-blue?style=for-the-badge&logo=electron"></a>
+  <a href="#"><img alt="Platform" src="https://img.shields.io/badge/Platform-macOS%20%7C%20Windows%20%7C%20Linux-blue?style=for-the-badge&logo=electron"></a>
   &nbsp;
   <a href="LICENSE"><img alt="License" src="https://img.shields.io/badge/License-GPL--3.0-green?style=for-the-badge"></a>
 </p>
@@ -67,7 +67,7 @@
 <a name="what-is-netcatty"></a>
 # What is Netcatty
 
-**Netcatty** is a modern SSH client and terminal manager for macOS and Windows, designed for developers, sysadmins, and DevOps engineers who need to manage multiple remote servers efficiently.
+**Netcatty** is a modern SSH client and terminal manager for macOS, Windows, and Linux, designed for developers, sysadmins, and DevOps engineers who need to manage multiple remote servers efficiently.
 
 - **Netcatty is** an alternative to PuTTY, Termius, SecureCRT, and macOS Terminal.app for SSH connections
 - **Netcatty is** a powerful SFTP client with dual-pane file browser
@@ -279,7 +279,7 @@ Or browse all releases at [GitHub Releases](https://github.com/binaricat/Netcatt
 
 ### Prerequisites
 - Node.js 18+ and npm
-- macOS or Windows 10+
+- macOS, Windows 10+, or Linux
 
 ### Development
 
@@ -329,6 +329,7 @@ npm run pack
 # Package for specific platforms
 npm run pack:mac     # macOS (DMG + ZIP)
 npm run pack:win     # Windows (NSIS installer)
+npm run pack:linux   # Linux (AppImage + DEB + RPM)
 ```
 
 ---

agents.md

@@ -31,6 +31,7 @@ This project is wired around three layers: domain (pure logic), application stat
 ## Data & Storage
 - Persisted keys: see `storageKeys.ts`. Use `localStorageAdapter` for all reads/writes.
 - Seed data: `config/defaultData.ts`; terminal themes: `config/terminalThemes.ts`.
+- **Temporary files**: All temporary files (e.g., SFTP downloaded files for external editing) must be written to Netcatty's dedicated temp directory via `tempDirBridge.getTempFilePath(fileName)`. Do not write directly to `os.tmpdir()`. This ensures proper cleanup and user visibility in Settings > System.
 
 ## Testing & Safety
 - Favor unit tests for domain helpers (e.g., `workspace.ts`, `host.ts`) and hook-level tests for application state.

application/i18n/locales/en.ts

@@ -61,6 +61,21 @@ const en: Messages = {
   'settings.tab.terminal': 'Terminal',
   'settings.tab.shortcuts': 'Shortcuts',
   'settings.tab.syncCloud': 'Sync & Cloud',
+  'settings.tab.system': 'System',
+
+  // Settings > System
+  'settings.system.title': 'System',
+  'settings.system.description': 'System information and temporary file management.',
+  'settings.system.tempDirectory': 'Temporary Files',
+  'settings.system.location': 'Location',
+  'settings.system.fileCount': 'Files',
+  'settings.system.totalSize': 'Size',
+  'settings.system.openFolder': 'Open folder',
+  'settings.system.refresh': 'Refresh',
+  'settings.system.clearTempFiles': 'Clear temp files',
+  'settings.system.clearing': 'Clearing...',
+  'settings.system.clearResult': 'Deleted {deleted} file(s), {failed} failed.',
+  'settings.system.tempDirectoryHint': 'Temporary files are created when opening remote files with external applications. They are automatically cleaned up when SFTP sessions close.',
 
   // Settings > Application
   'settings.application.checkUpdates': 'Check for updates',
@@ -107,6 +122,10 @@ const en: Messages = {
 
   // Settings > Terminal
   'settings.terminal.section.theme': 'Terminal Theme',
+  'settings.terminal.themeModal.title': 'Select Theme',
+  'settings.terminal.themeModal.darkThemes': 'Dark Themes',
+  'settings.terminal.themeModal.lightThemes': 'Light Themes',
+  'settings.terminal.theme.selectButton': 'Select Theme',
   'settings.terminal.section.font': 'Font',
   'settings.terminal.section.cursor': 'Cursor',
   'settings.terminal.section.keyboard': 'Keyboard',
@@ -179,6 +198,9 @@ const en: Messages = {
   'settings.terminal.localShell.startDir.placeholder': 'Home directory',
   'settings.terminal.localShell.startDir.notFound': 'Directory not found',
   'settings.terminal.localShell.startDir.isFile': 'Path is a file, not a directory',
+  'settings.terminal.section.connection': 'Connection',
+  'settings.terminal.connection.keepaliveInterval': 'Keepalive Interval',
+  'settings.terminal.connection.keepaliveInterval.desc': 'How often (in seconds) to send SSH-level keepalive packets to server. Set to 0 to disable.',
 
   // Settings > Shortcuts
   'settings.shortcuts.section.scheme': 'Hotkey Scheme',
@@ -372,6 +394,8 @@ const en: Messages = {
   'pf.deleteActive.title': 'Delete Active Port Forwarding?',
   'pf.deleteActive.desc': 'This port forwarding rule "{label}" is currently active. Deleting it will stop the tunnel first.',
   'pf.deleteActive.confirm': 'Stop and Delete',
+  'pf.form.autoStart': 'Auto Start',
+  'pf.form.autoStartDesc': 'Automatically start this rule when the app launches',
 
   // SFTP
   'sftp.newFolder': 'New Folder',
@@ -509,6 +533,20 @@ const en: Messages = {
   'settings.sftp.doubleClickBehavior.transfer': 'Transfer to other pane',
   'settings.sftp.doubleClickBehavior.openDesc': 'Open the file in the default application',
   'settings.sftp.doubleClickBehavior.transferDesc': 'Transfer the file to the other pane\'s active host',
+  
+  // Settings > SFTP Auto Sync
+  'settings.sftp.autoSync': 'Auto-sync to remote',
+  'settings.sftp.autoSync.desc': 'Automatically sync file changes back to the remote server when opening files with external applications',
+  'settings.sftp.autoSync.enable': 'Enable auto-sync',
+  'settings.sftp.autoSync.enableDesc': 'When you save a file in an external application, changes will be automatically uploaded to the remote server',
+  'sftp.autoSync.success': 'File synced to remote: {fileName}',
+  'sftp.autoSync.error': 'Failed to sync file: {error}',
+
+  // Settings > SFTP Show Hidden Files
+  'settings.sftp.showHiddenFiles': 'Show hidden files',
+  'settings.sftp.showHiddenFiles.desc': 'Display files with the Windows hidden attribute in the SFTP file browser when browsing local Windows filesystem.',
+  'settings.sftp.showHiddenFiles.enable': 'Show hidden files',
+  'settings.sftp.showHiddenFiles.enableDesc': 'Display Windows hidden files when browsing local filesystem',
 
   // Quick Switcher
   'qs.search.placeholder': 'Search hosts or tabs',
@@ -1029,11 +1067,12 @@ const en: Messages = {
   'serial.field.baudRate': 'Baud Rate',
   'serial.field.dataBits': 'Data Bits',
   'serial.field.stopBits': 'Stop Bits',
+  'serial.field.stopBits15Warning': '1.5 stop bits may not be supported on all Windows devices',
   'serial.field.parity': 'Parity',
   'serial.field.flowControl': 'Flow Control',
   'serial.noPorts': 'No serial ports detected. Connect a device and refresh.',
   'serial.field.customPort': 'Custom Port Path',
-  'serial.field.customPortPlaceholder': 'e.g. /dev/ttys001',
+  'serial.field.customPortPlaceholder': 'e.g. /dev/ttys001 or COM1',
   'serial.type.hardware': 'Hardware',
   'serial.type.pseudo': 'Pseudo Terminal',
   'serial.type.custom': 'Custom',

application/i18n/locales/zh-CN.ts

@@ -49,6 +49,21 @@ const zhCN: Messages = {
   'settings.tab.terminal': '终端',
   'settings.tab.shortcuts': '快捷键',
   'settings.tab.syncCloud': '同步与云',
+  'settings.tab.system': '系统',
+
+  // Settings > System
+  'settings.system.title': '系统',
+  'settings.system.description': '系统信息与临时文件管理。',
+  'settings.system.tempDirectory': '临时文件',
+  'settings.system.location': '位置',
+  'settings.system.fileCount': '文件数量',
+  'settings.system.totalSize': '占用空间',
+  'settings.system.openFolder': '打开文件夹',
+  'settings.system.refresh': '刷新',
+  'settings.system.clearTempFiles': '清理临时文件',
+  'settings.system.clearing': '清理中...',
+  'settings.system.clearResult': '已删除 {deleted} 个文件，{failed} 个失败。',
+  'settings.system.tempDirectoryHint': '临时文件在使用外部应用打开远程文件时创建。SFTP 会话关闭时会自动清理。',
 
   // Settings > Application
   'settings.application.checkUpdates': '检查更新',
@@ -674,6 +689,8 @@ const zhCN: Messages = {
   'pf.deleteActive.title': '删除正在运行的端口转发？',
   'pf.deleteActive.desc': '端口转发规则 "{label}" 当前正在运行。删除前将先关闭转发连接。',
   'pf.deleteActive.confirm': '关闭并删除',
+  'pf.form.autoStart': '自动启动',
+  'pf.form.autoStartDesc': '应用启动时自动开启此规则',
 
   // SFTP (pane + conflict)
   'sftp.pane.local': '本地',
@@ -748,9 +765,27 @@ const zhCN: Messages = {
   'settings.sftp.doubleClickBehavior.transfer': '传输到另一侧',
   'settings.sftp.doubleClickBehavior.openDesc': '使用默认应用程序打开文件',
   'settings.sftp.doubleClickBehavior.transferDesc': '将文件传输到另一窗格的活动主机',
+  
+  // Settings > SFTP Auto Sync
+  'settings.sftp.autoSync': '自动同步到远程',
+  'settings.sftp.autoSync.desc': '使用外部应用程序打开文件时，自动将文件更改同步回远程服务器',
+  'settings.sftp.autoSync.enable': '启用自动同步',
+  'settings.sftp.autoSync.enableDesc': '在外部应用程序中保存文件时，更改将自动上传到远程服务器',
+  'sftp.autoSync.success': '文件已同步到远程：{fileName}',
+  'sftp.autoSync.error': '同步文件失败：{error}',
+
+  // Settings > SFTP Show Hidden Files
+  'settings.sftp.showHiddenFiles': '显示隐藏文件',
+  'settings.sftp.showHiddenFiles.desc': '在浏览本地 Windows 文件系统时，显示具有 Windows 隐藏属性的文件。',
+  'settings.sftp.showHiddenFiles.enable': '显示隐藏文件',
+  'settings.sftp.showHiddenFiles.enableDesc': '浏览本地文件系统时显示 Windows 隐藏文件',
 
   // Settings > Terminal
   'settings.terminal.section.theme': '终端主题',
+  'settings.terminal.themeModal.title': '选择主题',
+  'settings.terminal.themeModal.darkThemes': '深色主题',
+  'settings.terminal.themeModal.lightThemes': '浅色主题',
+  'settings.terminal.theme.selectButton': '选择主题',
   'settings.terminal.section.font': '字体',
   'settings.terminal.section.cursor': '光标',
   'settings.terminal.section.keyboard': '键盘',
@@ -817,6 +852,9 @@ const zhCN: Messages = {
   'settings.terminal.localShell.startDir.placeholder': '用户主目录',
   'settings.terminal.localShell.startDir.notFound': '目录不存在',
   'settings.terminal.localShell.startDir.isFile': '路径是文件，不是目录',
+  'settings.terminal.section.connection': '连接',
+  'settings.terminal.connection.keepaliveInterval': '会话保持间隔',
+  'settings.terminal.connection.keepaliveInterval.desc': '向服务器发送 SSH 级别保活数据包的频率（秒）。设为 0 表示禁用。',
 
   // Settings > Shortcuts
   'settings.shortcuts.section.scheme': '快捷键方案',
@@ -1018,11 +1056,12 @@ const zhCN: Messages = {
   'serial.field.baudRate': '波特率',
   'serial.field.dataBits': '数据位',
   'serial.field.stopBits': '停止位',
+  'serial.field.stopBits15Warning': '1.5 停止位在 Windows 下可能不被所有设备支持',
   'serial.field.parity': '校验位',
   'serial.field.flowControl': '流控制',
   'serial.noPorts': '未检测到串口设备。请连接设备后刷新。',
   'serial.field.customPort': '自定义串口路径',
-  'serial.field.customPortPlaceholder': '例如 /dev/ttys001',
+  'serial.field.customPortPlaceholder': '例如 /dev/ttys001 或 COM1',
   'serial.type.hardware': '硬件',
   'serial.type.pseudo': '虚拟终端',
   'serial.type.custom': '自定义',

application/state/fontStore.ts

@@ -0,0 +1,146 @@
+import { useSyncExternalStore } from 'react';
+import { TERMINAL_FONTS, type TerminalFont } from '../../infrastructure/config/fonts';
+import { getMonospaceFonts } from '../../lib/localFonts';
+
+/**
+ * Global font store - singleton pattern using useSyncExternalStore
+ * Ensures fonts are loaded only once and shared across all components
+ */
+type Listener = () => void;
+
+interface FontStoreState {
+  availableFonts: TerminalFont[];
+  isLoading: boolean;
+  isLoaded: boolean;
+  error: string | null;
+}
+
+class FontStore {
+  private state: FontStoreState = {
+    availableFonts: TERMINAL_FONTS,
+    isLoading: false,
+    isLoaded: false,
+    error: null,
+  };
+  private listeners = new Set<Listener>();
+
+  // Getters for individual state slices
+  getAvailableFonts = (): TerminalFont[] => this.state.availableFonts;
+  getIsLoading = (): boolean => this.state.isLoading;
+  getIsLoaded = (): boolean => this.state.isLoaded;
+  getError = (): string | null => this.state.error;
+
+  private notify = () => {
+    // Defer listener notification to avoid "setState during render"
+    Promise.resolve().then(() => {
+      this.listeners.forEach(listener => listener());
+    });
+  };
+
+  private setState = (partial: Partial<FontStoreState>) => {
+    this.state = { ...this.state, ...partial };
+    this.notify();
+  };
+
+  subscribe = (listener: Listener): (() => void) => {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  };
+
+  /**
+   * Initialize font loading - safe to call multiple times,
+   * will only load once
+   */
+  initialize = async (): Promise<void> => {
+    // Already loaded or currently loading
+    if (this.state.isLoaded || this.state.isLoading) {
+      return;
+    }
+
+    this.setState({ isLoading: true, error: null });
+
+    try {
+      const localFonts = await getMonospaceFonts();
+      
+      // Combine default fonts with local fonts, deduplicate by id
+      const fontMap = new Map<string, TerminalFont>();
+
+      // Add default fonts first
+      TERMINAL_FONTS.forEach(font => fontMap.set(font.id, font));
+
+      // Add local fonts with a distinct ID namespace to avoid collisions
+      localFonts.forEach(font => {
+        const localId = font.id.startsWith('local-') ? font.id : `local-${font.id}`;
+        fontMap.set(localId, { ...font, id: localId });
+      });
+
+      this.setState({
+        availableFonts: Array.from(fontMap.values()),
+        isLoading: false,
+        isLoaded: true,
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : 'Failed to load local fonts';
+      console.warn('Failed to fetch local fonts, using defaults:', error);
+      this.setState({
+        availableFonts: TERMINAL_FONTS,
+        isLoading: false,
+        isLoaded: true,
+        error: errorMessage,
+      });
+    }
+  };
+
+  /**
+   * Find a font by ID with fallback
+   */
+  getFontById = (fontId: string): TerminalFont => {
+    const fonts = this.state.availableFonts;
+    return fonts.find(f => f.id === fontId) || fonts[0] || TERMINAL_FONTS[0];
+  };
+}
+
+// Singleton instance
+export const fontStore = new FontStore();
+
+// ============== Hooks ==============
+
+/**
+ * Get available fonts - triggers initialization on first use
+ */
+export const useAvailableFonts = (): TerminalFont[] => {
+  // Trigger initialization on first use
+  if (!fontStore.getIsLoaded() && !fontStore.getIsLoading()) {
+    fontStore.initialize();
+  }
+  
+  return useSyncExternalStore(
+    fontStore.subscribe,
+    fontStore.getAvailableFonts
+  );
+};
+
+/**
+ * Get font loading state
+ */
+export const useFontsLoading = (): boolean => {
+  return useSyncExternalStore(
+    fontStore.subscribe,
+    fontStore.getIsLoading
+  );
+};
+
+/**
+ * Get font by ID with fallback - useful for components that need a specific font
+ */
+export const useFontById = (fontId: string): TerminalFont => {
+  const fonts = useAvailableFonts();
+  return fonts.find(f => f.id === fontId) || fonts[0] || TERMINAL_FONTS[0];
+};
+
+/**
+ * Initialize fonts eagerly (call at app startup)
+ */
+export const initializeFonts = (): void => {
+  fontStore.initialize();
+};

application/state/usePortForwardingAutoStart.ts

@@ -0,0 +1,137 @@
+/**
+ * Hook for auto-starting port forwarding rules on app launch.
+ * This should be used at the App level to ensure auto-start happens
+ * when the application starts, not when the user navigates to the port forwarding page.
+ */
+import { useEffect, useRef } from "react";
+import { Host, PortForwardingRule } from "../../domain/models";
+import { STORAGE_KEY_PORT_FORWARDING } from "../../infrastructure/config/storageKeys";
+import { localStorageAdapter } from "../../infrastructure/persistence/localStorageAdapter";
+import {
+  getActiveConnection,
+  setReconnectCallback,
+  startPortForward,
+  syncWithBackend,
+} from "../../infrastructure/services/portForwardingService";
+import { logger } from "../../lib/logger";
+
+export interface UsePortForwardingAutoStartOptions {
+  hosts: Host[];
+  keys: { id: string; privateKey: string }[];
+}
+
+/**
+ * Auto-starts port forwarding rules that have autoStart enabled.
+ * This hook should be called at the App level to run on app launch.
+ */
+export const usePortForwardingAutoStart = ({
+  hosts,
+  keys,
+}: UsePortForwardingAutoStartOptions): void => {
+  const autoStartExecutedRef = useRef(false);
+  const hostsRef = useRef<Host[]>(hosts);
+  const keysRef = useRef<{ id: string; privateKey: string }[]>(keys);
+
+  // Keep refs in sync
+  useEffect(() => {
+    hostsRef.current = hosts;
+  }, [hosts]);
+
+  useEffect(() => {
+    keysRef.current = keys;
+  }, [keys]);
+
+  // Set up the reconnect callback
+  useEffect(() => {
+    const handleReconnect = async (
+      ruleId: string,
+      onStatusChange: (status: PortForwardingRule["status"], error?: string) => void,
+    ) => {
+      // Load the current rules from storage
+      const rules = localStorageAdapter.read<PortForwardingRule[]>(
+        STORAGE_KEY_PORT_FORWARDING,
+      ) ?? [];
+      
+      const rule = rules.find((r) => r.id === ruleId);
+      if (!rule || !rule.hostId) {
+        return { success: false, error: "Rule or host not found" };
+      }
+
+      const host = hostsRef.current.find((h) => h.id === rule.hostId);
+      if (!host) {
+        return { success: false, error: "Host not found" };
+      }
+
+      return startPortForward(rule, host, keysRef.current, onStatusChange, true);
+    };
+
+    setReconnectCallback(handleReconnect);
+    return () => {
+      setReconnectCallback(null);
+    };
+  }, []);
+
+  // Auto-start rules on app launch
+  useEffect(() => {
+    if (autoStartExecutedRef.current) return;
+    if (hosts.length === 0) return;
+
+    const runAutoStart = async () => {
+      // First sync with backend to get any active tunnels
+      await syncWithBackend();
+      
+      // Load rules from storage
+      const rules = localStorageAdapter.read<PortForwardingRule[]>(
+        STORAGE_KEY_PORT_FORWARDING,
+      ) ?? [];
+
+      // Only start rules that are not already active
+      const autoStartRules = rules.filter((r) => {
+        if (!r.autoStart || !r.hostId) return false;
+        // Check if there's an active connection for this rule
+        const conn = getActiveConnection(r.id);
+        // Only start if not already connecting or active
+        return !conn || conn.status === 'inactive' || conn.status === 'error';
+      });
+
+      if (autoStartRules.length === 0) return;
+
+      autoStartExecutedRef.current = true;
+      logger.info(`[PortForwardingAutoStart] Starting ${autoStartRules.length} auto-start rules`);
+
+      // Start each auto-start rule
+      for (const rule of autoStartRules) {
+        const host = hosts.find((h) => h.id === rule.hostId);
+        if (host) {
+          void startPortForward(
+            rule,
+            host,
+            keys,
+            (status, error) => {
+              // Update the rule status in storage
+              const currentRules = localStorageAdapter.read<PortForwardingRule[]>(
+                STORAGE_KEY_PORT_FORWARDING,
+              ) ?? [];
+              
+              const updatedRules = currentRules.map((r) =>
+                r.id === rule.id
+                  ? {
+                      ...r,
+                      status,
+                      error,
+                      lastUsedAt: status === "active" ? Date.now() : r.lastUsedAt,
+                    }
+                  : r,
+              );
+              
+              localStorageAdapter.write(STORAGE_KEY_PORT_FORWARDING, updatedRules);
+            },
+            true, // Enable reconnect for auto-start rules
+          );
+        }
+      }
+    };
+
+    void runAutoStart();
+  }, [hosts, keys]);
+};

application/state/usePortForwardingState.ts

@@ -7,6 +7,7 @@ import {
 } from "../../infrastructure/config/storageKeys";
 import { localStorageAdapter } from "../../infrastructure/persistence/localStorageAdapter";
 import {
+  clearReconnectTimer,
   getActiveConnection,
   getActiveRuleIds,
   startPortForward,
@@ -51,6 +52,7 @@ export interface UsePortForwardingStateResult {
     host: Host,
     keys: { id: string; privateKey: string }[],
     onStatusChange?: (status: PortForwardingRule["status"], error?: string) => void,
+    enableReconnect?: boolean,
   ) => Promise<{ success: boolean; error?: string }>;
   stopTunnel: (
     ruleId: string,
@@ -212,11 +214,12 @@ export const usePortForwardingState = (): UsePortForwardingStateResult => {
         status: PortForwardingRule["status"],
         error?: string,
       ) => void,
+      enableReconnect = false,
     ) => {
       return startPortForward(rule, host, keys, (status, error) => {
         setRuleStatus(rule.id, status, error);
         onStatusChange?.(status, error ?? undefined);
-      });
+      }, enableReconnect);
     },
     [setRuleStatus],
   );
@@ -226,6 +229,8 @@ export const usePortForwardingState = (): UsePortForwardingStateResult => {
       ruleId: string,
       onStatusChange?: (status: PortForwardingRule["status"]) => void,
     ) => {
+      // Clear any pending reconnect timer when manually stopping
+      clearReconnectTimer(ruleId);
       return stopPortForward(ruleId, (status) => {
         setRuleStatus(ruleId, status);
         onStatusChange?.(status);

application/state/useSettingsState.ts

@@ -17,11 +17,14 @@ STORAGE_KEY_ACCENT_MODE,
 STORAGE_KEY_UI_THEME_LIGHT,
 STORAGE_KEY_UI_THEME_DARK,
 STORAGE_KEY_SFTP_DOUBLE_CLICK_BEHAVIOR,
+STORAGE_KEY_SFTP_AUTO_SYNC,
+STORAGE_KEY_SFTP_SHOW_HIDDEN_FILES,
 } from '../../infrastructure/config/storageKeys';
 import { DEFAULT_UI_LOCALE, resolveSupportedLocale } from '../../infrastructure/config/i18n';
 import { TERMINAL_THEMES } from '../../infrastructure/config/terminalThemes';
-import { TERMINAL_FONTS, DEFAULT_FONT_SIZE } from '../../infrastructure/config/fonts';
+import { DEFAULT_FONT_SIZE } from '../../infrastructure/config/fonts';
 import { DARK_UI_THEMES, LIGHT_UI_THEMES, UiThemeTokens, getUiThemeById } from '../../infrastructure/config/uiThemes';
+import { useAvailableFonts } from './fontStore';
 import { localStorageAdapter } from '../../infrastructure/persistence/localStorageAdapter';
 import { netcattyBridge } from '../../infrastructure/services/netcattyBridge';
 
@@ -33,11 +36,13 @@ const DEFAULT_CUSTOM_ACCENT = '221.2 83.2% 53.3%';
 const DEFAULT_TERMINAL_THEME = 'netcatty-dark';
 const DEFAULT_FONT_FAMILY = 'menlo';
 // Auto-detect default hotkey scheme based on platform
-const DEFAULT_HOTKEY_SCHEME: HotkeyScheme = 
-  typeof navigator !== 'undefined' && /Mac|iPhone|iPad|iPod/i.test(navigator.platform) 
-    ? 'mac' 
+const DEFAULT_HOTKEY_SCHEME: HotkeyScheme =
+  typeof navigator !== 'undefined' && /Mac|iPhone|iPad|iPod/i.test(navigator.platform)
+    ? 'mac'
     : 'pc';
 const DEFAULT_SFTP_DOUBLE_CLICK_BEHAVIOR: 'open' | 'transfer' = 'open';
+const DEFAULT_SFTP_AUTO_SYNC = false;
+const DEFAULT_SFTP_SHOW_HIDDEN_FILES = false;
 
 const readStoredString = (key: string): string | null => {
   const raw = localStorageAdapter.readString(key);
@@ -99,13 +104,14 @@ const applyThemeTokens = (
   root.style.setProperty('--border', tokens.border);
   root.style.setProperty('--input', tokens.input);
   root.style.setProperty('--ring', accentToken);
-  
+
   // Sync with native window title bar (Electron)
   netcattyBridge.get()?.setTheme?.(theme);
   netcattyBridge.get()?.setBackgroundColor?.(tokens.background);
 };
 
 export const useSettingsState = () => {
+  const availableFonts = useAvailableFonts();
   const [theme, setTheme] = useState<'dark' | 'light'>(() => {
     const stored = readStoredString(STORAGE_KEY_THEME);
     return stored && isValidTheme(stored) ? stored : DEFAULT_THEME;
@@ -148,17 +154,25 @@ export const useSettingsState = () => {
     }
     return DEFAULT_HOTKEY_SCHEME;
   });
-  const [customKeyBindings, setCustomKeyBindings] = useState<CustomKeyBindings>(() => 
+  const [customKeyBindings, setCustomKeyBindings] = useState<CustomKeyBindings>(() =>
     localStorageAdapter.read<CustomKeyBindings>(STORAGE_KEY_CUSTOM_KEY_BINDINGS) || {}
   );
   const [isHotkeyRecording, setIsHotkeyRecordingState] = useState(false);
-  const [customCSS, setCustomCSS] = useState<string>(() => 
+  const [customCSS, setCustomCSS] = useState<string>(() =>
     localStorageAdapter.readString(STORAGE_KEY_CUSTOM_CSS) || ''
   );
   const [sftpDoubleClickBehavior, setSftpDoubleClickBehavior] = useState<'open' | 'transfer'>(() => {
     const stored = readStoredString(STORAGE_KEY_SFTP_DOUBLE_CLICK_BEHAVIOR);
     return (stored === 'open' || stored === 'transfer') ? stored : DEFAULT_SFTP_DOUBLE_CLICK_BEHAVIOR;
   });
+  const [sftpAutoSync, setSftpAutoSync] = useState<boolean>(() => {
+    const stored = readStoredString(STORAGE_KEY_SFTP_AUTO_SYNC);
+    return stored === 'true' ? true : DEFAULT_SFTP_AUTO_SYNC;
+  });
+  const [sftpShowHiddenFiles, setSftpShowHiddenFiles] = useState<boolean>(() => {
+    const stored = readStoredString(STORAGE_KEY_SFTP_SHOW_HIDDEN_FILES);
+    return stored === 'true' ? true : DEFAULT_SFTP_SHOW_HIDDEN_FILES;
+  });
 
   // Helper to notify other windows about settings changes via IPC
   const notifySettingsChanged = useCallback((key: string, value: unknown) => {
@@ -383,11 +397,25 @@ export const useSettingsState = () => {
           setSftpDoubleClickBehavior(e.newValue);
         }
       }
+      // Sync SFTP auto-sync setting from other windows
+      if (e.key === STORAGE_KEY_SFTP_AUTO_SYNC && e.newValue !== null) {
+        const newValue = e.newValue === 'true';
+        if (newValue !== sftpAutoSync) {
+          setSftpAutoSync(newValue);
+        }
+      }
+      // Sync SFTP show hidden files setting from other windows
+      if (e.key === STORAGE_KEY_SFTP_SHOW_HIDDEN_FILES && e.newValue !== null) {
+        const newValue = e.newValue === 'true';
+        if (newValue !== sftpShowHiddenFiles) {
+          setSftpShowHiddenFiles(newValue);
+        }
+      }
     };
 
     window.addEventListener('storage', handleStorageChange);
     return () => window.removeEventListener('storage', handleStorageChange);
-  }, [theme, lightUiThemeId, darkUiThemeId, accentMode, customAccent, customCSS, hotkeyScheme, uiLanguage, terminalThemeId, terminalFontFamilyId, terminalFontSize, sftpDoubleClickBehavior]);
+  }, [theme, lightUiThemeId, darkUiThemeId, accentMode, customAccent, customCSS, hotkeyScheme, uiLanguage, terminalThemeId, terminalFontFamilyId, terminalFontSize, sftpDoubleClickBehavior, sftpAutoSync, sftpShowHiddenFiles]);
 
   useEffect(() => {
     localStorageAdapter.writeString(STORAGE_KEY_TERM_THEME, terminalThemeId);
@@ -427,7 +455,7 @@ export const useSettingsState = () => {
   useEffect(() => {
     localStorageAdapter.writeString(STORAGE_KEY_CUSTOM_CSS, customCSS);
     notifySettingsChanged(STORAGE_KEY_CUSTOM_CSS, customCSS);
-    
+
     // Apply custom CSS to document
     let styleEl = document.getElementById('netcatty-custom-css') as HTMLStyleElement | null;
     if (!styleEl) {
@@ -444,6 +472,18 @@ export const useSettingsState = () => {
     notifySettingsChanged(STORAGE_KEY_SFTP_DOUBLE_CLICK_BEHAVIOR, sftpDoubleClickBehavior);
   }, [sftpDoubleClickBehavior, notifySettingsChanged]);
 
+  // Persist SFTP auto-sync setting
+  useEffect(() => {
+    localStorageAdapter.writeString(STORAGE_KEY_SFTP_AUTO_SYNC, sftpAutoSync ? 'true' : 'false');
+    notifySettingsChanged(STORAGE_KEY_SFTP_AUTO_SYNC, sftpAutoSync);
+  }, [sftpAutoSync, notifySettingsChanged]);
+
+  // Persist SFTP show hidden files setting
+  useEffect(() => {
+    localStorageAdapter.writeString(STORAGE_KEY_SFTP_SHOW_HIDDEN_FILES, sftpShowHiddenFiles ? 'true' : 'false');
+    notifySettingsChanged(STORAGE_KEY_SFTP_SHOW_HIDDEN_FILES, sftpShowHiddenFiles);
+  }, [sftpShowHiddenFiles, notifySettingsChanged]);
+
   // Get merged key bindings (defaults + custom overrides)
   const keyBindings = useMemo((): KeyBinding[] => {
     return DEFAULT_KEY_BINDINGS.map(binding => {
@@ -502,8 +542,8 @@ export const useSettingsState = () => {
   );
 
   const currentTerminalFont = useMemo(
-    () => TERMINAL_FONTS.find(f => f.id === terminalFontFamilyId) || TERMINAL_FONTS[0],
-    [terminalFontFamilyId]
+    () => availableFonts.find(f => f.id === terminalFontFamilyId) || availableFonts[0],
+    [terminalFontFamilyId, availableFonts]
   );
 
   const updateTerminalSetting = useCallback(<K extends keyof TerminalSettings>(
@@ -552,5 +592,10 @@ export const useSettingsState = () => {
     setCustomCSS,
     sftpDoubleClickBehavior,
     setSftpDoubleClickBehavior,
+    sftpAutoSync,
+    setSftpAutoSync,
+    sftpShowHiddenFiles,
+    setSftpShowHiddenFiles,
+    availableFonts,
   };
 };

application/state/useSftpBackend.ts

@@ -184,16 +184,51 @@ export const useSftpBackend = () => {
     sftpId: string,
     remotePath: string,
     fileName: string,
-    appPath: string
-  ) => {
+    appPath: string,
+    options?: { enableWatch?: boolean }
+  ): Promise<{ localTempPath: string; watchId?: string }> => {
     const bridge = netcattyBridge.get();
     if (!bridge?.downloadSftpToTemp || !bridge?.openWithApplication) {
       throw new Error("Download to temp / open with unavailable");
     }
+    
     // Download the file to temp
+    console.log("[SFTPBackend] Downloading file to temp", { sftpId, remotePath, fileName });
     const tempPath = await bridge.downloadSftpToTemp(sftpId, remotePath, fileName);
+    console.log("[SFTPBackend] File downloaded to temp", { tempPath });
+    
+    // Register temp file for cleanup when SFTP session closes (regardless of auto-sync setting)
+    if (bridge.registerTempFile) {
+      try {
+        await bridge.registerTempFile(sftpId, tempPath);
+      } catch (err) {
+        console.warn("[SFTPBackend] Failed to register temp file for cleanup:", err);
+      }
+    }
+    
     // Open with the selected application
+    console.log("[SFTPBackend] Opening with application", { tempPath, appPath });
     await bridge.openWithApplication(tempPath, appPath);
+    console.log("[SFTPBackend] Application launched");
+    
+    // Start file watching if enabled
+    let watchId: string | undefined;
+    console.log("[SFTPBackend] Auto-sync enabled check", { enableWatch: options?.enableWatch, hasStartFileWatch: !!bridge.startFileWatch });
+    if (options?.enableWatch && bridge.startFileWatch) {
+      try {
+        console.log("[SFTPBackend] Starting file watch", { tempPath, remotePath, sftpId });
+        const result = await bridge.startFileWatch(tempPath, remotePath, sftpId);
+        watchId = result.watchId;
+        console.log("[SFTPBackend] File watch started successfully", { watchId, tempPath, remotePath });
+      } catch (err) {
+        console.warn("[SFTPBackend] Failed to start file watch:", err);
+        // Don't fail the operation if watching fails
+      }
+    } else {
+      console.log("[SFTPBackend] File watching not enabled or not available");
+    }
+    
+    return { localTempPath: tempPath, watchId };
   }, []);
 
   return {

application/state/useSftpState.ts

@@ -143,7 +143,32 @@ const createEmptyPane = (id?: string): SftpPane => ({
   filter: "",
 });
 
-export const useSftpState = (hosts: Host[], keys: SSHKey[], identities: Identity[]) => {
+// File watch event types
+export interface FileWatchSyncedEvent {
+  watchId: string;
+  localPath: string;
+  remotePath: string;
+  bytesWritten: number;
+}
+
+export interface FileWatchErrorEvent {
+  watchId: string;
+  localPath: string;
+  remotePath: string;
+  error: string;
+}
+
+export interface SftpStateOptions {
+  onFileWatchSynced?: (event: FileWatchSyncedEvent) => void;
+  onFileWatchError?: (event: FileWatchErrorEvent) => void;
+}
+
+export const useSftpState = (
+  hosts: Host[],
+  keys: SSHKey[],
+  identities: Identity[],
+  options?: SftpStateOptions
+) => {
   // Multi-tab state: left and right sides each have multiple tabs
   const [leftTabs, setLeftTabs] = useState<SftpSideTabs>({
     tabs: [],
@@ -540,6 +565,29 @@ export const useSftpState = (hosts: Host[], keys: SSHKey[], identities: Identity
     };
   }, []);
 
+  // Listen for file watch events (auto-sync feature)
+  useEffect(() => {
+    const bridge = netcattyBridge.get();
+    if (!bridge?.onFileWatchSynced || !bridge?.onFileWatchError) return;
+    
+    const unsubscribeSynced = bridge.onFileWatchSynced((payload: FileWatchSyncedEvent) => {
+      options?.onFileWatchSynced?.(payload);
+    });
+    
+    const unsubscribeError = bridge.onFileWatchError((payload: FileWatchErrorEvent) => {
+      options?.onFileWatchError?.(payload);
+    });
+    
+    return () => {
+      try {
+        unsubscribeSynced?.();
+        unsubscribeError?.();
+      } catch {
+        // ignore cleanup errors
+      }
+    };
+  }, [options]);
+
   // Track if initial auto-connect has been done
   const initialConnectDoneRef = useRef(false);
 
@@ -628,6 +676,7 @@ export const useSftpState = (hosts: Host[], keys: SSHKey[], identities: Identity
           lastModified: new Date(f.lastModified).getTime(),
           lastModifiedFormatted: f.lastModified,
           linkTarget: f.linkTarget as "file" | "directory" | null | undefined,
+          hidden: f.hidden, // Windows hidden attribute
         };
       });
     },
@@ -2604,8 +2653,16 @@ export const useSftpState = (hosts: Host[], keys: SSHKey[], identities: Identity
   );
 
   // Download file to temp directory and open with external application
+  // If enableWatch is true and the file is remote, starts watching the temp file for changes
+  // Returns { localTempPath, watchId } if watch was started, otherwise just { localTempPath }
   const downloadToTempAndOpen = useCallback(
-    async (side: "left" | "right", remotePath: string, fileName: string, appPath: string): Promise<void> => {
+    async (
+      side: "left" | "right",
+      remotePath: string,
+      fileName: string,
+      appPath: string,
+      options?: { enableWatch?: boolean }
+    ): Promise<{ localTempPath: string; watchId?: string }> => {
       const pane = getActivePane(side);
       if (!pane?.connection) {
         throw new Error("No connection available");
@@ -2617,9 +2674,9 @@ export const useSftpState = (hosts: Host[], keys: SSHKey[], identities: Identity
       }
 
       if (pane.connection.isLocal) {
-        // For local files, just open directly
+        // For local files, just open directly (no watching needed)
         await bridge.openWithApplication(remotePath, appPath);
-        return;
+        return { localTempPath: remotePath };
       }
 
       const sftpId = sftpSessionsRef.current.get(pane.connection.id);
@@ -2628,14 +2685,129 @@ export const useSftpState = (hosts: Host[], keys: SSHKey[], identities: Identity
       }
 
       // Download to temp directory
+      console.log("[SFTP] Downloading file to temp", { sftpId, remotePath, fileName });
       const localTempPath = await bridge.downloadSftpToTemp(sftpId, remotePath, fileName);
+      console.log("[SFTP] File downloaded to temp", { localTempPath });
+      
+      // Register temp file for cleanup when SFTP session closes (regardless of auto-sync setting)
+      if (bridge.registerTempFile) {
+        try {
+          await bridge.registerTempFile(sftpId, localTempPath);
+        } catch (err) {
+          console.warn("[SFTP] Failed to register temp file for cleanup:", err);
+        }
+      }
       
       // Open with the selected application
+      console.log("[SFTP] Opening with application", { localTempPath, appPath });
       await bridge.openWithApplication(localTempPath, appPath);
+      console.log("[SFTP] Application launched");
+      
+      // Start file watching if enabled
+      let watchId: string | undefined;
+      console.log("[SFTP] Auto-sync enabled check", { enableWatch: options?.enableWatch, hasStartFileWatch: !!bridge.startFileWatch });
+      if (options?.enableWatch && bridge.startFileWatch) {
+        try {
+          console.log("[SFTP] Starting file watch", { localTempPath, remotePath, sftpId });
+          const result = await bridge.startFileWatch(localTempPath, remotePath, sftpId);
+          watchId = result.watchId;
+          console.log("[SFTP] File watch started successfully", { watchId, localTempPath, remotePath });
+        } catch (err) {
+          console.warn("[SFTP] Failed to start file watch:", err);
+          // Don't fail the operation if watching fails
+        }
+      } else {
+        console.log("[SFTP] File watching not enabled or not available");
+      }
+      
+      return { localTempPath, watchId };
     },
     [getActivePane],
   );
 
+  // Upload external files dropped from OS
+  const uploadExternalFiles = useCallback(
+    async (side: "left" | "right", files: FileList) => {
+      const pane = getActivePane(side);
+      if (!pane?.connection) {
+        throw new Error("No active connection");
+      }
+
+      const bridge = netcattyBridge.get();
+      if (!bridge) {
+        throw new Error("Bridge not available");
+      }
+
+      const results: { fileName: string; success: boolean; error?: string }[] = [];
+
+      for (const file of Array.from(files)) {
+        const targetPath = joinPath(pane.connection.currentPath, file.name);
+        
+        try {
+          const arrayBuffer = await file.arrayBuffer();
+          
+          if (pane.connection.isLocal) {
+            // Upload to local filesystem
+            if (!bridge.writeLocalFile) {
+              throw new Error("writeLocalFile not available");
+            }
+            await bridge.writeLocalFile(targetPath, arrayBuffer);
+          } else {
+            // Upload to remote via SFTP
+            const sftpId = sftpSessionsRef.current.get(pane.connection.id);
+            if (!sftpId) {
+              throw new Error("SFTP session not found");
+            }
+            
+            // Try progress API first, fallback to basic binary write
+            if (bridge.writeSftpBinaryWithProgress) {
+              const result = await bridge.writeSftpBinaryWithProgress(
+                sftpId,
+                targetPath,
+                arrayBuffer,
+                crypto.randomUUID(),
+                // Progress callbacks not needed for simple drag-drop upload
+                undefined, // onProgress
+                undefined, // onComplete
+                undefined, // onError
+              );
+              
+              // Check if progress API explicitly reported failure
+              // If result is undefined/null or success is false, fallback to basic API
+              if (!result || result.success === false) {
+                if (bridge.writeSftpBinary) {
+                  await bridge.writeSftpBinary(sftpId, targetPath, arrayBuffer);
+                } else {
+                  throw new Error("Upload failed and no fallback method available");
+                }
+              }
+            } else if (bridge.writeSftpBinary) {
+              // Progress API not available, use basic API
+              await bridge.writeSftpBinary(sftpId, targetPath, arrayBuffer);
+            } else {
+              throw new Error("No SFTP write method available");
+            }
+          }
+          
+          results.push({ fileName: file.name, success: true });
+        } catch (error) {
+          logger.error(`Failed to upload ${file.name}:`, error);
+          results.push({
+            fileName: file.name,
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+          });
+        }
+      }
+      
+      // Refresh the file list to show new files
+      await refresh(side);
+      
+      return results;
+    },
+    [getActivePane, refresh],
+  );
+
   // Select an application from system file picker
   const selectApplication = useCallback(
     async (): Promise<{ path: string; name: string } | null> => {
@@ -2679,6 +2851,7 @@ export const useSftpState = (hosts: Host[], keys: SSHKey[], identities: Identity
     readBinaryFile,
     writeTextFile,
     downloadToTempAndOpen,
+    uploadExternalFiles,
     selectApplication,
     startTransfer,
     cancelTransfer,
@@ -2716,6 +2889,7 @@ export const useSftpState = (hosts: Host[], keys: SSHKey[], identities: Identity
     readBinaryFile,
     writeTextFile,
     downloadToTempAndOpen,
+    uploadExternalFiles,
     selectApplication,
     startTransfer,
     cancelTransfer,
@@ -2756,6 +2930,7 @@ export const useSftpState = (hosts: Host[], keys: SSHKey[], identities: Identity
     readBinaryFile: (...args: Parameters<typeof readBinaryFile>) => methodsRef.current.readBinaryFile(...args),
     writeTextFile: (...args: Parameters<typeof writeTextFile>) => methodsRef.current.writeTextFile(...args),
     downloadToTempAndOpen: (...args: Parameters<typeof downloadToTempAndOpen>) => methodsRef.current.downloadToTempAndOpen(...args),
+    uploadExternalFiles: (...args: Parameters<typeof uploadExternalFiles>) => methodsRef.current.uploadExternalFiles(...args),
     selectApplication: () => methodsRef.current.selectApplication(),
     startTransfer: (...args: Parameters<typeof startTransfer>) => methodsRef.current.startTransfer(...args),
     cancelTransfer: (...args: Parameters<typeof cancelTransfer>) => methodsRef.current.cancelTransfer(...args),

components/HostDetailsPanel.tsx

@@ -522,12 +522,16 @@ const HostDetailsPanel: React.FC<HostDetailsPanelProps> = ({
             <Combobox
               options={groupOptions}
               value={form.group || ""}
-              onValueChange={(val) => update("group", val)}
+              onValueChange={(val) => {
+                update("group", val);
+                setGroupInputValue(val);
+              }}
               placeholder={t("hostDetails.group.placeholder")}
               allowCreate={true}
               onCreateNew={(val) => {
                 onCreateGroup?.(val);
                 update("group", val);
+                setGroupInputValue(val);
               }}
               createText="Create Group"
               triggerClassName="flex-1 h-10"

components/PortForwardingNew.tsx

@@ -138,6 +138,7 @@ const PortForwarding: React.FC<PortForwardingProps> = ({
               );
             }
           },
+          rule.autoStart, // Enable reconnect for auto-start rules
         );
         // Show error from result only if not already shown
         if (!result.success && result.error && !errorShown) {

components/SFTPModal.tsx

@@ -43,10 +43,12 @@ import React, {
 import { useI18n } from "../application/i18n/I18nProvider";
 import { useSftpBackend } from "../application/state/useSftpBackend";
 import { useSftpFileAssociations } from "../application/state/useSftpFileAssociations";
+import { useSettingsState } from "../application/state/useSettingsState";
 import { logger } from "../lib/logger";
 import { getFileExtension, isKnownBinaryFile, FileOpenerType, SystemAppInfo } from "../lib/sftpFileUtils";
 import { cn } from "../lib/utils";
 import { Host, RemoteFile } from "../types";
+import { filterHiddenFiles } from "./sftp";
 import { DistroAvatar } from "./DistroAvatar";
 import FileOpenerDialog from "./FileOpenerDialog";
 import TextEditorModal from "./TextEditorModal";
@@ -255,6 +257,8 @@ interface SFTPModalProps {
   };
   open: boolean;
   onClose: () => void;
+  /** Initial path to open in SFTP. If not accessible, falls back to home directory. */
+  initialPath?: string;
 }
 
 // Sort configuration
@@ -279,6 +283,7 @@ const SFTPModal: React.FC<SFTPModalProps> = ({
   credentials,
   open,
   onClose,
+  initialPath,
 }) => {
   const {
     openSftp,
@@ -303,6 +308,7 @@ const SFTPModal: React.FC<SFTPModalProps> = ({
     downloadSftpToTempAndOpen,
   } = useSftpBackend();
   const { t, resolvedLocale } = useI18n();
+  const { sftpAutoSync, sftpShowHiddenFiles } = useSettingsState();
   const isLocalSession = host.protocol === "local";
   const [currentPath, setCurrentPath] = useState("/");
   const [files, setFiles] = useState<RemoteFile[]>([]);
@@ -314,6 +320,7 @@ const SFTPModal: React.FC<SFTPModalProps> = ({
   const inputRef = useRef<HTMLInputElement>(null);
   const sftpIdRef = useRef<string | null>(null);
   const initializedRef = useRef(false);
+  const lastInitialPathRef = useRef<string | undefined>(undefined);
   const navigatingRef = useRef(false);
   const lastSelectedIndexRef = useRef<number | null>(null);
   const localHomeRef = useRef<string | null>(null);
@@ -610,8 +617,12 @@ const SFTPModal: React.FC<SFTPModalProps> = ({
 
   useEffect(() => {
     if (open) {
-      if (!initializedRef.current) {
+      // Check if we need to reinitialize (either first time or initialPath changed)
+      const needsReinit = !initializedRef.current || initialPath !== lastInitialPathRef.current;
+
+      if (needsReinit) {
         initializedRef.current = true;
+        lastInitialPathRef.current = initialPath;
         if (isLocalSession) {
           void (async () => {
             let home = localHomeRef.current;
@@ -626,7 +637,7 @@ const SFTPModal: React.FC<SFTPModalProps> = ({
             loadFiles(startPath);
           })();
         } else {
-          // For remote sessions, load home directory directly
+          // For remote sessions, try initialPath first, then fall back to home directory
           void (async () => {
             const username = credentials.username || 'root';
             // Root user's home is /root, other users' home is /home/username
@@ -635,6 +646,26 @@ const SFTPModal: React.FC<SFTPModalProps> = ({
             // Set loading state immediately for better UX
             setLoading(true);
 
+            // If initialPath is provided, try to use it first
+            if (initialPath) {
+              try {
+                const sftpId = await ensureSftp();
+                const list = await listSftp(sftpId, initialPath);
+                setCurrentPath(initialPath);
+                setFiles(list);
+                setSelectedFiles(new Set());
+                dirCacheRef.current.set(`${host.id}::${initialPath}`, {
+                  files: list,
+                  timestamp: Date.now(),
+                });
+                setLoading(false);
+                return; // Successfully opened at initialPath
+              } catch {
+                // initialPath not accessible, fall back to home directory
+                logger.warn(`[SFTP] Initial path ${initialPath} not accessible, falling back to home`);
+              }
+            }
+
             try {
               const sftpId = await ensureSftp();
               const list = await listSftp(sftpId, homePath);
@@ -677,7 +708,7 @@ const SFTPModal: React.FC<SFTPModalProps> = ({
       void closeSftpSession();
       initializedRef.current = false;
     }
-  }, [open, currentPath, loadFiles, closeSftpSession, getHomeDir, isLocalSession, credentials.username, ensureSftp, listSftp, host.id, t]);
+  }, [open, currentPath, loadFiles, closeSftpSession, getHomeDir, isLocalSession, credentials.username, ensureSftp, listSftp, host.id, t, initialPath]);
 
   const handleNavigate = useCallback((path: string) => {
     // Prevent double navigation (e.g., from double-click race condition)
@@ -1163,7 +1194,7 @@ const SFTPModal: React.FC<SFTPModalProps> = ({
             }
           } else {
             const sftpId = await ensureSftp();
-            await downloadSftpToTempAndOpen(sftpId, fullPath, file.name, savedOpener.systemApp.path);
+            await downloadSftpToTempAndOpen(sftpId, fullPath, file.name, savedOpener.systemApp.path, { enableWatch: sftpAutoSync });
           }
         } catch (e) {
           toast.error(
@@ -1176,7 +1207,7 @@ const SFTPModal: React.FC<SFTPModalProps> = ({
       // Show opener dialog
       openFileOpenerDialog(file);
     }
-  }, [getOpenerForFile, handleEditFile, openFileOpenerDialog, joinPath, currentPath, isLocalSession, ensureSftp, downloadSftpToTempAndOpen, t]);
+  }, [getOpenerForFile, handleEditFile, openFileOpenerDialog, joinPath, currentPath, isLocalSession, ensureSftp, downloadSftpToTempAndOpen, sftpAutoSync, t]);
 
   const handleFileOpenerSelect = useCallback(async (openerType: FileOpenerType, setAsDefault: boolean, systemApp?: SystemAppInfo) => {
     if (!fileOpenerTarget) return;
@@ -1203,7 +1234,7 @@ const SFTPModal: React.FC<SFTPModalProps> = ({
           }
         } else {
           const sftpId = await ensureSftp();
-          await downloadSftpToTempAndOpen(sftpId, fullPath, fileOpenerTarget.name, systemApp.path);
+          await downloadSftpToTempAndOpen(sftpId, fullPath, fileOpenerTarget.name, systemApp.path, { enableWatch: sftpAutoSync });
         }
       } catch (e) {
         toast.error(
@@ -1214,7 +1245,7 @@ const SFTPModal: React.FC<SFTPModalProps> = ({
     }
 
     setFileOpenerTarget(null);
-  }, [fileOpenerTarget, setOpenerForExtension, handleEditFile, joinPath, currentPath, isLocalSession, ensureSftp, downloadSftpToTempAndOpen, t]);
+  }, [fileOpenerTarget, setOpenerForExtension, handleEditFile, joinPath, currentPath, isLocalSession, ensureSftp, downloadSftpToTempAndOpen, sftpAutoSync, t]);
 
   // Callback for FileOpenerDialog to select a system application
   const handleSelectSystemApp = useCallback(async (): Promise<SystemAppInfo | null> => {
@@ -1261,9 +1292,12 @@ const SFTPModal: React.FC<SFTPModalProps> = ({
 
   // Display files with parent entry (like SftpView)
   const displayFiles = useMemo(() => {
+    // Filter hidden files using utility function
+    const visibleFiles = filterHiddenFiles(files, sftpShowHiddenFiles);
+
     // Check if we're at root
     const atRoot = isRootPath(currentPath);
-    if (atRoot) return files;
+    if (atRoot) return visibleFiles;
 
     // Add ".." parent directory entry at the top (only if not at root)
     const parentEntry: RemoteFile = {
@@ -1272,8 +1306,8 @@ const SFTPModal: React.FC<SFTPModalProps> = ({
       size: "--",
       lastModified: undefined,
     };
-    return [parentEntry, ...files.filter((f) => f.name !== "..")];
-  }, [files, currentPath, isRootPath]);
+    return [parentEntry, ...visibleFiles.filter((f) => f.name !== "..")];
+  }, [files, currentPath, isRootPath, sftpShowHiddenFiles]);
 
   // Sorted files
   const sortedFiles = useMemo(() => {

components/SerialConnectModal.tsx

@@ -114,9 +114,16 @@ export const SerialConnectModal: React.FC<SerialConnectModalProps> = ({
     }));
   }, [ports]);
 
-  // Validate: port path must start with /dev/
-  const isPortValid = selectedPort.trim().startsWith('/dev/');
+  // Validate: port path must start with /dev/ (Unix/macOS) or COM/\\.\COM (Windows)
+  const trimmedPort = selectedPort.trim();
+  const isPortValid =
+    trimmedPort.startsWith('/dev/') ||
+    /^COM\d+$/i.test(trimmedPort) ||
+    /^\\\\\.\\COM\d+$/i.test(trimmedPort);
   const isBaudRateValid = BAUD_RATES.includes(baudRate);
+
+  // Check if using 1.5 stop bits (limited Windows support)
+  const isStopBits15 = stopBits === 1.5;
   const isValid = isPortValid && isBaudRateValid;
 
   return (
@@ -236,6 +243,11 @@ export const SerialConnectModal: React.FC<SerialConnectModalProps> = ({
                       </option>
                     ))}
                   </select>
+                  {isStopBits15 && (
+                    <p className="text-xs text-yellow-500">
+                      {t('serial.field.stopBits15Warning')}
+                    </p>
+                  )}
                 </div>
               </div>
 

components/SettingsPage.tsx

@@ -2,7 +2,7 @@
  * Settings Page - Standalone settings window content
  * This component is rendered in a separate Electron window
  */
-import { AppWindow, Cloud, FileType, Keyboard, Palette, TerminalSquare, X } from "lucide-react";
+import { AppWindow, Cloud, FileType, HardDrive, Keyboard, Palette, TerminalSquare, X } from "lucide-react";
 import React, { useCallback, useEffect, useState } from "react";
 import { useSettingsState } from "../application/state/useSettingsState";
 import { useVaultState } from "../application/state/useVaultState";
@@ -13,11 +13,15 @@ import SettingsAppearanceTab from "./settings/tabs/SettingsAppearanceTab";
 import SettingsFileAssociationsTab from "./settings/tabs/SettingsFileAssociationsTab";
 import SettingsShortcutsTab from "./settings/tabs/SettingsShortcutsTab";
 import SettingsTerminalTab from "./settings/tabs/SettingsTerminalTab";
+import SettingsSystemTab from "./settings/tabs/SettingsSystemTab";
 import { Tabs, TabsList, TabsTrigger } from "./ui/tabs";
+import type { TerminalFont } from "../infrastructure/config/fonts";
 
 const isMac = typeof navigator !== "undefined" && /Mac|iPhone|iPad/.test(navigator.platform);
 
-type SettingsState = ReturnType<typeof useSettingsState>;
+type SettingsState = ReturnType<typeof useSettingsState> & {
+    availableFonts: TerminalFont[];
+};
 
 const SettingsSyncTab = React.lazy(() => import("./settings/tabs/SettingsSyncTab"));
 
@@ -130,6 +134,12 @@ const SettingsPageContent: React.FC<{ settings: SettingsState }> = ({ settings }
                         >
                             <Cloud size={14} /> {t("settings.tab.syncCloud")}
                         </TabsTrigger>
+                        <TabsTrigger
+                            value="system"
+                            className="w-full justify-start gap-2 px-3 py-2 text-sm data-[state=active]:bg-background hover:bg-background/60 rounded-md transition-colors"
+                        >
+                            <HardDrive size={14} /> {t("settings.tab.system")}
+                        </TabsTrigger>
                     </TabsList>
                 </div>
 
@@ -165,6 +175,7 @@ const SettingsPageContent: React.FC<{ settings: SettingsState }> = ({ settings }
                             setTerminalFontSize={settings.setTerminalFontSize}
                             terminalSettings={settings.terminalSettings}
                             updateTerminalSetting={settings.updateTerminalSetting}
+                            availableFonts={settings.availableFonts}
                         />
                     )}
 
@@ -189,6 +200,8 @@ const SettingsPageContent: React.FC<{ settings: SettingsState }> = ({ settings }
                             <SettingsSyncTabWithVault />
                         </React.Suspense>
                     )}
+
+                    {mountedTabs.has("system") && <SettingsSystemTab />}
                 </div>
             </Tabs>
         </div>

components/SftpView.tsx

@@ -59,6 +59,7 @@ import { Label } from "./ui/label";
 // Import extracted components
 import {
   ColumnWidths,
+  filterHiddenFiles,
   isNavigableDirectory,
   SftpBreadcrumb,
   SftpConflictDialog,
@@ -100,6 +101,7 @@ import {
   useSftpPaneCallbacks,
   useSftpDrag,
   useSftpHosts,
+  useSftpShowHiddenFiles,
   useActiveTabId,
   activeTabStore,
   type SftpPaneCallbacks,
@@ -162,6 +164,7 @@ const SftpPaneViewInner: React.FC<SftpPaneViewProps> = ({
   const callbacks = useSftpPaneCallbacks(side);
   const { draggedFiles, onDragStart, onDragEnd } = useSftpDrag();
   const hosts = useSftpHosts();
+  const showHiddenFiles = useSftpShowHiddenFiles();
 
   // Destructure for easier use
   const {
@@ -182,8 +185,9 @@ const SftpPaneViewInner: React.FC<SftpPaneViewProps> = ({
     onReceiveFromOtherPane,
     onEditPermissions,
     onEditFile,
-    onOpenFile,
     onOpenFileWith,
+    onDownloadFile,
+    onUploadExternalFiles,
   } = callbacks;
 
   // 渲染追踪 - 只追踪数据 props（回调来自 context，引用稳定）
@@ -255,11 +259,16 @@ const SftpPaneViewInner: React.FC<SftpPaneViewProps> = ({
 
   const filteredFiles = useMemo(() => {
     const term = pane.filter.trim().toLowerCase();
-    if (!term) return pane.files;
-    return pane.files.filter(
+
+    // Filter hidden files using utility function
+    let files = filterHiddenFiles(pane.files, showHiddenFiles);
+
+    // Apply text filter
+    if (!term) return files;
+    return files.filter(
       (f) => f.name === ".." || f.name.toLowerCase().includes(term),
     );
-  }, [pane.files, pane.filter]);
+  }, [pane.files, pane.filter, showHiddenFiles]);
 
   // Path suggestions
   const pathSuggestions = useMemo(() => {
@@ -593,6 +602,18 @@ const SftpPaneViewInner: React.FC<SftpPaneViewProps> = ({
 
   // Drag handlers
   const handlePaneDragOver = (e: React.DragEvent) => {
+    // Check if this is external file drag (from OS)
+    const hasFiles = e.dataTransfer.types.includes('Files');
+
+    // If it's external files, always allow drop
+    if (hasFiles) {
+      e.preventDefault();
+      e.dataTransfer.dropEffect = "copy";
+      setIsDragOverPane(true);
+      return;
+    }
+
+    // Otherwise, check if it's internal drag from other pane
     if (!draggedFiles || draggedFiles[0]?.side === side) return;
     e.preventDefault();
     e.dataTransfer.dropEffect = "copy";
@@ -607,11 +628,23 @@ const SftpPaneViewInner: React.FC<SftpPaneViewProps> = ({
     setDragOverEntry(null);
   };
 
-  const handlePaneDrop = (e: React.DragEvent) => {
+  const handlePaneDrop = async (e: React.DragEvent) => {
     e.preventDefault();
     e.stopPropagation();
     setIsDragOverPane(false);
     setDragOverEntry(null);
+
+    // Check if this is external file drop (from OS)
+    const droppedFiles = e.dataTransfer.files;
+    if (droppedFiles && droppedFiles.length > 0) {
+      // Handle external file upload using the callback
+      if (onUploadExternalFiles) {
+        await onUploadExternalFiles(droppedFiles);
+      }
+      return;
+    }
+
+    // Otherwise, handle internal drag from other pane
     if (!draggedFiles || draggedFiles[0]?.side === side) return;
     onReceiveFromOtherPane(
       draggedFiles.map((f) => ({ name: f.name, isDirectory: f.isDirectory })),
@@ -814,18 +847,11 @@ const SftpPaneViewInner: React.FC<SftpPaneViewProps> = ({
                 </>
               ) : (
                 <>
-                  <Download size={14} className="mr-2" />{" "}
-                  {t("sftp.context.download")}
+                  <ExternalLink size={14} className="mr-2" />{" "}
+                  {t("sftp.context.open")}
                 </>
               )}
             </ContextMenuItem>
-            {/* File operations - only for files, not directories */}
-            {!isNavigableDirectory(entry) && onOpenFile && (
-              <ContextMenuItem onClick={() => onOpenFile(entry)}>
-                <ExternalLink size={14} className="mr-2" />{" "}
-                {t("sftp.context.open")}
-              </ContextMenuItem>
-            )}
             {!isNavigableDirectory(entry) && onOpenFileWith && (
               <ContextMenuItem onClick={() => onOpenFileWith(entry)}>
                 <ExternalLink size={14} className="mr-2" />{" "}
@@ -838,6 +864,12 @@ const SftpPaneViewInner: React.FC<SftpPaneViewProps> = ({
                 {t("sftp.context.edit")}
               </ContextMenuItem>
             )}
+            {!isNavigableDirectory(entry) && onDownloadFile && (
+              <ContextMenuItem onClick={() => onDownloadFile(entry)}>
+                <Download size={14} className="mr-2" />{" "}
+                {t("sftp.context.download")}
+              </ContextMenuItem>
+            )}
             <ContextMenuSeparator />
             <ContextMenuItem
               onClick={() => {
@@ -901,10 +933,10 @@ const SftpPaneViewInner: React.FC<SftpPaneViewProps> = ({
       handleRowOpen,
       handleRowSelect,
       onCopyToOtherPane,
+      onDownloadFile,
       onDragEnd,
       onEditFile,
       onEditPermissions,
-      onOpenFile,
       onOpenFileWith,
       onRefresh,
       openDeleteConfirm,
@@ -1480,8 +1512,22 @@ interface SftpViewProps {
 const SftpViewInner: React.FC<SftpViewProps> = ({ hosts, keys, identities }) => {
   const { t } = useI18n();
   const isActive = useIsSftpActive();
-  const sftp = useSftpState(hosts, keys, identities);
-  const { sftpDoubleClickBehavior } = useSettingsState();
+  const { sftpDoubleClickBehavior, sftpAutoSync, sftpShowHiddenFiles } = useSettingsState();
+
+  // File watch event handlers (stable refs to avoid re-creating the useSftpState options)
+  const fileWatchHandlers = useMemo(() => ({
+    onFileWatchSynced: (payload: { remotePath: string }) => {
+      const fileName = payload.remotePath.split('/').pop() || payload.remotePath;
+      toast.success(t('sftp.autoSync.success', { fileName }));
+      logger.info("[SFTP] File auto-synced to remote", payload);
+    },
+    onFileWatchError: (payload: { error: string }) => {
+      toast.error(t('sftp.autoSync.error', { error: payload.error }));
+      logger.error("[SFTP] File auto-sync failed", payload);
+    },
+  }), [t]);
+
+  const sftp = useSftpState(hosts, keys, identities, fileWatchHandlers);
 
   // Store sftp in a ref so callbacks can access the latest instance
   // without needing to re-create when sftp changes
@@ -1492,6 +1538,10 @@ const SftpViewInner: React.FC<SftpViewProps> = ({ hosts, keys, identities }) =>
   const behaviorRef = useRef(sftpDoubleClickBehavior);
   behaviorRef.current = sftpDoubleClickBehavior;
 
+  // Store auto-sync setting in ref for stable callbacks
+  const autoSyncRef = useRef(sftpAutoSync);
+  autoSyncRef.current = sftpAutoSync;
+
   // Sync activeTabId to external store (allows child components to subscribe without parent re-render)
   // Using useLayoutEffect to sync before paint
   useLayoutEffect(() => {
@@ -1743,7 +1793,8 @@ const SftpViewInner: React.FC<SftpViewProps> = ({ hosts, keys, identities }) =>
               side,
               fullPath,
               file.name,
-              savedOpener.systemApp.path
+              savedOpener.systemApp.path,
+              { enableWatch: autoSyncRef.current }
             );
           } catch (e) {
             toast.error(
@@ -1785,7 +1836,8 @@ const SftpViewInner: React.FC<SftpViewProps> = ({ hosts, keys, identities }) =>
             fileOpenerTarget.side,
             fileOpenerTarget.fullPath,
             fileOpenerTarget.file.name,
-            systemApp.path
+            systemApp.path,
+            { enableWatch: autoSyncRef.current }
           );
         } catch (e) {
           toast.error(
@@ -1862,6 +1914,100 @@ const SftpViewInner: React.FC<SftpViewProps> = ({ hosts, keys, identities }) =>
     [handleOpenFileWithForSide],
   );
 
+  // Handle external file upload from OS drag-and-drop (shared logic)
+  // Uses sftpRef.current internally, so dependencies are stable.
+  // toast and logger are globally stable, t is the only real dependency.
+  const handleUploadExternalFilesForSide = useCallback(
+    async (side: "left" | "right", files: FileList) => {
+      try {
+        const results = await sftpRef.current.uploadExternalFiles(side, files);
+        const failCount = results.filter(r => !r.success).length;
+
+        if (failCount === 0) {
+          // All files uploaded successfully
+          const successCount = results.length;
+          const message = successCount === 1
+            ? `${t('sftp.upload')}: ${results[0].fileName}`
+            : `${t('sftp.uploadFiles')}: ${successCount}`;
+          toast.success(message, "SFTP");
+        } else {
+          // Some or all files failed
+          const failedFiles = results.filter(r => !r.success);
+          failedFiles.forEach(failed => {
+            const errorMsg = failed.error ? ` - ${failed.error}` : '';
+            toast.error(
+              `${t('sftp.error.uploadFailed')}: ${failed.fileName}${errorMsg}`,
+              "SFTP"
+            );
+          });
+        }
+      } catch (error) {
+        logger.error("[SftpView] Failed to upload external files:", error);
+        toast.error(
+          error instanceof Error ? error.message : t('sftp.error.uploadFailed'),
+          "SFTP"
+        );
+      }
+    },
+
+    [t],
+  );
+
+  const handleUploadExternalFilesLeft = useCallback(
+    (files: FileList) => handleUploadExternalFilesForSide("left", files),
+    [handleUploadExternalFilesForSide],
+  );
+
+  const handleUploadExternalFilesRight = useCallback(
+    (files: FileList) => handleUploadExternalFilesForSide("right", files),
+    [handleUploadExternalFilesForSide],
+  );
+
+  // Download file to local filesystem (browser download)
+  const handleDownloadFileForSide = useCallback(
+    async (side: "left" | "right", file: SftpFileEntry) => {
+      const pane = side === "left" ? sftpRef.current.leftPane : sftpRef.current.rightPane;
+      if (!pane.connection) return;
+
+      const fullPath = sftpRef.current.joinPath(pane.connection.currentPath, file.name);
+
+      try {
+        // Read the file as binary
+        const content = await sftpRef.current.readBinaryFile(side, fullPath);
+
+        // Create blob and trigger browser download
+        const blob = new Blob([content], { type: "application/octet-stream" });
+        const url = URL.createObjectURL(blob);
+        const a = document.createElement("a");
+        a.href = url;
+        a.download = file.name;
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+        URL.revokeObjectURL(url);
+
+        toast.success(`${t('sftp.context.download')}: ${file.name}`, "SFTP");
+      } catch (e) {
+        logger.error("[SftpView] Failed to download file:", e);
+        toast.error(
+          e instanceof Error ? e.message : t('sftp.error.downloadFailed'),
+          "SFTP"
+        );
+      }
+    },
+    [t],
+  );
+
+  const handleDownloadFileLeft = useCallback(
+    (file: SftpFileEntry) => handleDownloadFileForSide("left", file),
+    [handleDownloadFileForSide],
+  );
+
+  const handleDownloadFileRight = useCallback(
+    (file: SftpFileEntry) => handleDownloadFileForSide("right", file),
+    [handleDownloadFileForSide],
+  );
+
   // Custom handleOpenEntry callbacks that check the double-click behavior setting
   const handleOpenEntryLeft = useCallback(
     (entry: SftpFileEntry) => {
@@ -1939,6 +2085,8 @@ const SftpViewInner: React.FC<SftpViewProps> = ({ hosts, keys, identities }) =>
       onEditFile: handleEditFileLeft,
       onOpenFile: handleOpenFileLeft,
       onOpenFileWith: handleOpenFileWithLeft,
+      onDownloadFile: handleDownloadFileLeft,
+      onUploadExternalFiles: handleUploadExternalFilesLeft,
     }),
     [],
   );
@@ -1964,6 +2112,8 @@ const SftpViewInner: React.FC<SftpViewProps> = ({ hosts, keys, identities }) =>
       onEditFile: handleEditFileRight,
       onOpenFile: handleOpenFileRight,
       onOpenFileWith: handleOpenFileWithRight,
+      onDownloadFile: handleDownloadFileRight,
+      onUploadExternalFiles: handleUploadExternalFilesRight,
     }),
     [],
   );
@@ -2104,6 +2254,7 @@ const SftpViewInner: React.FC<SftpViewProps> = ({ hosts, keys, identities }) =>
       dragCallbacks={dragCallbacks}
       leftCallbacks={leftCallbacks}
       rightCallbacks={rightCallbacks}
+      showHiddenFiles={sftpShowHiddenFiles}
     >
       <div
         className={cn(

components/SyncStatusButton.tsx

@@ -1,12 +1,12 @@
 /**
  * SyncStatusButton - Cloud Sync Status Indicator for Top Bar
- * 
+ *
  * Shows current sync state with cloud icon and colored indicators:
  * - Green dot: All synced
- * - Blue dot + spin: Syncing in progress  
+ * - Blue dot + spin: Syncing in progress
  * - Red dot: Error
  * - Gray dot: No providers connected
- * 
+ *
  * Clicking opens a popover with sync status details and history.
  */
 
@@ -239,7 +239,7 @@ export const SyncStatusButton: React.FC<SyncStatusButtonProps> = ({
                             <CloudOff size={32} className="mx-auto mb-2 text-muted-foreground" />
                             <p className="text-sm font-medium mb-1">{t('sync.notConfigured')}</p>
                             <p className="text-xs text-muted-foreground mb-3">
-                                Connect a cloud provider to sync your data across devices.
+                                {t('sync.autoSync.noProvider')}
                             </p>
                             <Button
                                 size="sm"
@@ -249,7 +249,7 @@ export const SyncStatusButton: React.FC<SyncStatusButtonProps> = ({
                                     onOpenSettings?.();
                                 }}
                             >
-                                Configure Cloud Sync
+                                {t('sync.settings')}
                             </Button>
                         </div>
                     ) : (

components/Terminal.tsx

@@ -5,6 +5,7 @@ import { SearchAddon } from "@xterm/addon-search";
 import "@xterm/xterm/css/xterm.css";
 import { Maximize2, Radio } from "lucide-react";
 import React, { memo, useEffect, useMemo, useRef, useState } from "react";
+import { flushSync } from "react-dom";
 import { useI18n } from "../application/i18n/I18nProvider";
 import { logger } from "../lib/logger";
 import { cn } from "../lib/utils";
@@ -26,7 +27,7 @@ import KnownHostConfirmDialog, { HostKeyInfo } from "./KnownHostConfirmDialog";
 import SFTPModal from "./SFTPModal";
 import { Button } from "./ui/button";
 import { toast } from "./ui/toast";
-import { TERMINAL_FONTS } from "../infrastructure/config/fonts";
+import { useAvailableFonts } from "../application/state/fontStore";
 import { TERMINAL_THEMES } from "../infrastructure/config/terminalThemes";
 
 import { TerminalConnectionDialog } from "./terminal/TerminalConnectionDialog";
@@ -129,6 +130,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
 }) => {
   const CONNECTION_TIMEOUT = 12000;
   const { t } = useI18n();
+  const availableFonts = useAvailableFonts();
   const containerRef = useRef<HTMLDivElement>(null);
   const termRef = useRef<XTerm | null>(null);
   const fitAddonRef = useRef<FitAddon | null>(null);
@@ -180,6 +182,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
   const [timeLeft, setTimeLeft] = useState(CONNECTION_TIMEOUT / 1000);
   const [isCancelling, setIsCancelling] = useState(false);
   const [showSFTP, setShowSFTP] = useState(false);
+  const [sftpInitialPath, setSftpInitialPath] = useState<string | undefined>(undefined);
   const [progressValue, setProgressValue] = useState(15);
   const [hasSelection, setHasSelection] = useState(false);
 
@@ -551,7 +554,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
       termRef.current.options.fontSize = effectiveFontSize;
 
       const hostFontId = host.fontFamily || fontFamilyId || "menlo";
-      const fontObj = TERMINAL_FONTS.find((f) => f.id === hostFontId) || TERMINAL_FONTS[0];
+      const fontObj = availableFonts.find((f) => f.id === hostFontId) || availableFonts[0];
       termRef.current.options.fontFamily = fontObj.family;
 
       termRef.current.options.theme = {
@@ -561,7 +564,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
 
       setTimeout(() => safeFit(), 50);
     }
-  }, [host.fontSize, host.fontFamily, host.theme, fontFamilyId, fontSize, effectiveTheme]);
+  }, [host.fontSize, host.fontFamily, host.theme, fontFamilyId, fontSize, effectiveTheme, availableFonts]);
 
   useEffect(() => {
     if (isVisible && fitAddonRef.current) {
@@ -731,6 +734,34 @@ const TerminalComponent: React.FC<TerminalProps> = ({
     termRef.current?.writeln("\r\n[No active SSH session]");
   };
 
+  const handleOpenSFTP = async () => {
+    // If SFTP is already open, toggle it off
+    if (showSFTP) {
+      setShowSFTP(false);
+      return;
+    }
+
+    // Try to get the current working directory from the terminal session
+    let initialPath: string | undefined = undefined;
+    if (sessionRef.current) {
+      try {
+        const result = await terminalBackend.getSessionPwd(sessionRef.current);
+        if (result.success && result.cwd) {
+          initialPath = result.cwd;
+        }
+      } catch {
+        // Silently fail and open SFTP without initial path
+      }
+    }
+
+    // Use flushSync to ensure initialPath state is committed before opening SFTP modal
+    // This prevents React's batching from causing the modal to open with stale/undefined initialPath
+    flushSync(() => {
+      setSftpInitialPath(initialPath);
+    });
+    setShowSFTP(true);
+  };
+
   const handleCancelConnect = () => {
     setIsCancelling(true);
     auth.setNeedsAuth(false);
@@ -809,7 +840,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
       onUpdateTerminalFontSize={onUpdateTerminalFontSize}
       isScriptsOpen={isScriptsOpen}
       setIsScriptsOpen={setIsScriptsOpen}
-      onOpenSFTP={() => setShowSFTP((v) => !v)}
+      onOpenSFTP={handleOpenSFTP}
       onSnippetClick={handleSnippetClick}
       onUpdateHost={onUpdateHost}
       showClose={opts?.showClose}
@@ -1052,6 +1083,7 @@ const TerminalComponent: React.FC<TerminalProps> = ({
           })()}
           open={showSFTP && status === "connected"}
           onClose={() => setShowSFTP(false)}
+          initialPath={sftpInitialPath}
         />
       </div>
     </TerminalContextMenu>

components/TextEditorModal.tsx

@@ -95,6 +95,9 @@ export const TextEditorModal: React.FC<TextEditorModalProps> = ({
   const [hasChanges, setHasChanges] = useState(false);
   const [languageId, setLanguageId] = useState(() => getLanguageId(fileName));
   const editorRef = useRef<Monaco.editor.IStandaloneCodeEditor | null>(null);
+  
+  // Ref to store the latest save function to avoid stale closure in keyboard shortcut
+  const handleSaveRef = useRef<() => Promise<void>>(() => Promise.resolve());
 
   // Track theme from document.documentElement class (syncs with app theme)
   const [isDarkTheme, setIsDarkTheme] = useState(() =>
@@ -140,6 +143,11 @@ export const TextEditorModal: React.FC<TextEditorModalProps> = ({
     }
   }, [content, onSave, saving, t]);
 
+  // Keep the ref updated with the latest handleSave function
+  useEffect(() => {
+    handleSaveRef.current = handleSave;
+  }, [handleSave]);
+
   const handleClose = useCallback(() => {
     if (hasChanges) {
       const confirmed = confirm(t('sftp.editor.unsavedChanges'));
@@ -155,9 +163,9 @@ export const TextEditorModal: React.FC<TextEditorModalProps> = ({
   const handleEditorMount: OnMount = useCallback((editor, monaco) => {
     editorRef.current = editor;
 
-    // Add save shortcut
+    // Add save shortcut - use ref to avoid stale closure
     editor.addCommand(monaco.KeyMod.CtrlCmd | monaco.KeyCode.KeyS, () => {
-      handleSave();
+      handleSaveRef.current();
     });
 
     // Add find shortcut (Ctrl+F / Cmd+F)
@@ -165,7 +173,7 @@ export const TextEditorModal: React.FC<TextEditorModalProps> = ({
       // Trigger Monaco's built-in find widget
       editor.trigger('keyboard', 'actions.find', null);
     });
-  }, [handleSave]);
+  }, []);
 
   // Trigger search dialog
   const handleSearch = useCallback(() => {

components/port-forwarding/EditPanel.tsx

@@ -12,6 +12,7 @@ import { AsideActionMenu,AsideActionMenuItem,AsidePanel,AsidePanelContent,AsideP
 import { Button } from '../ui/button';
 import { Input } from '../ui/input';
 import { Label } from '../ui/label';
+import { Switch } from '../ui/switch';
 
 export interface EditPanelProps {
     rule: PortForwardingRule;
@@ -152,6 +153,18 @@ export const EditPanel: React.FC<EditPanelProps> = ({
                         </div>
                     </>
                 )}
+
+                {/* Auto Start Toggle */}
+                <div className="flex items-center justify-between py-2">
+                    <div className="space-y-0.5">
+                        <Label className="text-sm font-medium">{t('pf.form.autoStart')}</Label>
+                        <p className="text-[10px] text-muted-foreground">{t('pf.form.autoStartDesc')}</p>
+                    </div>
+                    <Switch
+                        checked={draft.autoStart ?? false}
+                        onCheckedChange={checked => onDraftChange({ autoStart: checked })}
+                    />
+                </div>
             </AsidePanelContent>
             <AsidePanelFooter className="space-y-2">
                 <Button

components/port-forwarding/NewFormPanel.tsx

@@ -13,6 +13,7 @@ import { AsidePanel,AsidePanelContent,AsidePanelFooter } from '../ui/aside-panel
 import { Button } from '../ui/button';
 import { Input } from '../ui/input';
 import { Label } from '../ui/label';
+import { Switch } from '../ui/switch';
 import { getTypeLabel } from './utils';
 
 export interface NewFormPanelProps {
@@ -153,6 +154,18 @@ export const NewFormPanel: React.FC<NewFormPanelProps> = ({
                         </div>
                     </>
                 )}
+
+                {/* Auto Start Toggle */}
+                <div className="flex items-center justify-between py-2">
+                    <div className="space-y-0.5">
+                        <Label className="text-sm font-medium">{t('pf.form.autoStart')}</Label>
+                        <p className="text-[10px] text-muted-foreground">{t('pf.form.autoStartDesc')}</p>
+                    </div>
+                    <Switch
+                        checked={draft.autoStart ?? false}
+                        onCheckedChange={checked => onDraftChange({ autoStart: checked })}
+                    />
+                </div>
             </AsidePanelContent>
             <AsidePanelFooter className="space-y-2">
                 <Button

components/settings/ThemeSelectModal.tsx

@@ -0,0 +1,186 @@
+/**
+ * Theme Select Modal
+ * A modal dialog for selecting terminal themes in settings
+ */
+
+import React, { memo, useCallback, useMemo } from 'react';
+import { createPortal } from 'react-dom';
+import { Check, Palette, X } from 'lucide-react';
+import { useI18n } from '../../application/i18n/I18nProvider';
+import { TERMINAL_THEMES, TerminalThemeConfig } from '../../infrastructure/config/terminalThemes';
+import { Button } from '../ui/button';
+import { cn } from '../../lib/utils';
+
+// Memoized theme item component to prevent unnecessary re-renders
+const ThemeItem = memo(({
+    theme,
+    isSelected,
+    onSelect
+}: {
+    theme: TerminalThemeConfig;
+    isSelected: boolean;
+    onSelect: (id: string) => void;
+}) => (
+    <button
+        onClick={() => onSelect(theme.id)}
+        className={cn(
+            'w-full flex items-center gap-3 px-3 py-2.5 rounded-lg text-left transition-all',
+            isSelected
+                ? 'bg-primary/15 ring-1 ring-primary'
+                : 'hover:bg-muted'
+        )}
+    >
+        {/* Color swatch preview */}
+        <div
+            className="w-12 h-8 rounded-md flex-shrink-0 flex flex-col justify-center items-start pl-1.5 gap-0.5 border border-border/50"
+            style={{ backgroundColor: theme.colors.background }}
+        >
+            <div className="h-1 w-4 rounded-full" style={{ backgroundColor: theme.colors.green }} />
+            <div className="h-1 w-6 rounded-full" style={{ backgroundColor: theme.colors.blue }} />
+            <div className="h-1 w-3 rounded-full" style={{ backgroundColor: theme.colors.yellow }} />
+        </div>
+        <div className="flex-1 min-w-0">
+            <div className={cn('text-sm font-medium truncate', isSelected ? 'text-primary' : 'text-foreground')}>
+                {theme.name}
+            </div>
+            <div className="text-[10px] text-muted-foreground capitalize">{theme.type}</div>
+        </div>
+        {isSelected && (
+            <Check size={16} className="text-primary flex-shrink-0" />
+        )}
+    </button>
+));
+ThemeItem.displayName = 'ThemeItem';
+
+interface ThemeSelectModalProps {
+    open: boolean;
+    onClose: () => void;
+    selectedThemeId: string;
+    onSelect: (themeId: string) => void;
+}
+
+export const ThemeSelectModal: React.FC<ThemeSelectModalProps> = ({
+    open,
+    onClose,
+    selectedThemeId,
+    onSelect,
+}) => {
+    const { t } = useI18n();
+
+    // Group themes by type
+    const { darkThemes, lightThemes } = useMemo(() => {
+        const dark = TERMINAL_THEMES.filter(t => t.type === 'dark');
+        const light = TERMINAL_THEMES.filter(t => t.type === 'light');
+        return { darkThemes: dark, lightThemes: light };
+    }, []);
+
+    // Handle theme selection - select and close
+    const handleThemeSelect = useCallback((themeId: string) => {
+        onSelect(themeId);
+        onClose();
+    }, [onSelect, onClose]);
+
+    // Handle ESC key
+    React.useEffect(() => {
+        if (!open) return;
+        const handleKeyDown = (e: KeyboardEvent) => {
+            if (e.key === 'Escape') onClose();
+        };
+        document.addEventListener('keydown', handleKeyDown);
+        return () => document.removeEventListener('keydown', handleKeyDown);
+    }, [open, onClose]);
+
+    // Handle backdrop click
+    const handleBackdropClick = useCallback((e: React.MouseEvent) => {
+        if (e.target === e.currentTarget) onClose();
+    }, [onClose]);
+
+    if (!open) return null;
+
+    const modalTitleId = 'theme-select-modal-title';
+
+    const modalContent = (
+        <div
+            className="fixed inset-0 flex items-center justify-center bg-black/60"
+            style={{ zIndex: 99999 }}
+            onClick={handleBackdropClick}
+            role="dialog"
+            aria-modal="true"
+            aria-labelledby={modalTitleId}
+        >
+            <div
+                className="w-[480px] max-h-[600px] bg-background border border-border rounded-2xl shadow-2xl flex flex-col overflow-hidden animate-in fade-in zoom-in-95 duration-200"
+                onClick={(e) => e.stopPropagation()}
+            >
+                {/* Header */}
+                <div className="flex items-center justify-between px-5 py-3 shrink-0 border-b border-border">
+                    <div className="flex items-center gap-3">
+                        <div className="w-8 h-8 rounded-lg flex items-center justify-center bg-primary/10">
+                            <Palette size={16} className="text-primary" />
+                        </div>
+                        <h2 id={modalTitleId} className="text-sm font-semibold text-foreground">{t('settings.terminal.themeModal.title')}</h2>
+                    </div>
+                    <button
+                        onClick={onClose}
+                        className="w-8 h-8 rounded-lg flex items-center justify-center text-muted-foreground hover:text-foreground hover:bg-muted transition-colors"
+                        aria-label={t('common.close')}
+                    >
+                        <X size={16} />
+                    </button>
+                </div>
+
+                {/* Theme List */}
+                <div className="flex-1 min-h-0 overflow-y-auto p-4">
+                    {/* Dark Themes Section */}
+                    <div className="mb-4">
+                        <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-2 font-semibold px-1">
+                            {t('settings.terminal.themeModal.darkThemes')}
+                        </div>
+                        <div className="space-y-1">
+                            {darkThemes.map(theme => (
+                                <ThemeItem
+                                    key={theme.id}
+                                    theme={theme}
+                                    isSelected={selectedThemeId === theme.id}
+                                    onSelect={handleThemeSelect}
+                                />
+                            ))}
+                        </div>
+                    </div>
+
+                    {/* Light Themes Section */}
+                    <div>
+                        <div className="text-[10px] uppercase tracking-wider text-muted-foreground mb-2 font-semibold px-1">
+                            {t('settings.terminal.themeModal.lightThemes')}
+                        </div>
+                        <div className="space-y-1">
+                            {lightThemes.map(theme => (
+                                <ThemeItem
+                                    key={theme.id}
+                                    theme={theme}
+                                    isSelected={selectedThemeId === theme.id}
+                                    onSelect={handleThemeSelect}
+                                />
+                            ))}
+                        </div>
+                    </div>
+                </div>
+
+                {/* Footer */}
+                <div className="flex justify-end px-5 py-3 shrink-0 border-t border-border bg-muted/20">
+                    <Button
+                        variant="ghost"
+                        onClick={onClose}
+                    >
+                        {t('common.cancel')}
+                    </Button>
+                </div>
+            </div>
+        </div>
+    );
+
+    // Use Portal to render at document root
+    return createPortal(modalContent, document.body);
+};
+
+export default ThemeSelectModal;

components/settings/tabs/SettingsFileAssociationsTab.tsx

@@ -29,7 +29,7 @@ const getOpenerLabel = (
 export default function SettingsFileAssociationsTab() {
   const { t } = useI18n();
   const { getAllAssociations, removeAssociation, setOpenerForExtension } = useSftpFileAssociations();
-  const { sftpDoubleClickBehavior, setSftpDoubleClickBehavior } = useSettingsState();
+  const { sftpDoubleClickBehavior, setSftpDoubleClickBehavior, sftpAutoSync, setSftpAutoSync, sftpShowHiddenFiles, setSftpShowHiddenFiles } = useSettingsState();
   const associations = getAllAssociations();
   const [editingExtension, setEditingExtension] = useState<string | null>(null);
 
@@ -133,6 +133,86 @@ export default function SettingsFileAssociationsTab() {
           </div>
         </div>
 
+        {/* Auto-sync section */}
+        <div className="space-y-4">
+          <SectionHeader title={t('settings.sftp.autoSync')} />
+          <p className="text-sm text-muted-foreground">
+            {t('settings.sftp.autoSync.desc')}
+          </p>
+          <button
+            onClick={() => setSftpAutoSync(!sftpAutoSync)}
+            className={cn(
+              "w-full text-left p-4 rounded-lg border-2 transition-colors",
+              sftpAutoSync
+                ? "border-primary bg-primary/5"
+                : "border-border hover:border-primary/50 hover:bg-secondary/50"
+            )}
+          >
+            <div className="flex items-start gap-3">
+              <div className={cn(
+                "h-5 w-5 rounded border-2 flex items-center justify-center mt-0.5 shrink-0",
+                sftpAutoSync
+                  ? "border-primary bg-primary"
+                  : "border-muted-foreground/30"
+              )}>
+                {sftpAutoSync && (
+                  <svg className="h-3 w-3 text-primary-foreground" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={3}>
+                    <path strokeLinecap="round" strokeLinejoin="round" d="M5 13l4 4L19 7" />
+                  </svg>
+                )}
+              </div>
+              <div className="space-y-1">
+                <Label className="font-medium cursor-pointer">
+                  {t('settings.sftp.autoSync.enable')}
+                </Label>
+                <p className="text-sm text-muted-foreground">
+                  {t('settings.sftp.autoSync.enableDesc')}
+                </p>
+              </div>
+            </div>
+          </button>
+        </div>
+
+        {/* Show hidden files section */}
+        <div className="space-y-4">
+          <SectionHeader title={t('settings.sftp.showHiddenFiles')} />
+          <p className="text-sm text-muted-foreground">
+            {t('settings.sftp.showHiddenFiles.desc')}
+          </p>
+          <button
+            onClick={() => setSftpShowHiddenFiles(!sftpShowHiddenFiles)}
+            className={cn(
+              "w-full text-left p-4 rounded-lg border-2 transition-colors",
+              sftpShowHiddenFiles
+                ? "border-primary bg-primary/5"
+                : "border-border hover:border-primary/50 hover:bg-secondary/50"
+            )}
+          >
+            <div className="flex items-start gap-3">
+              <div className={cn(
+                "h-5 w-5 rounded border-2 flex items-center justify-center mt-0.5 shrink-0",
+                sftpShowHiddenFiles
+                  ? "border-primary bg-primary"
+                  : "border-muted-foreground/30"
+              )}>
+                {sftpShowHiddenFiles && (
+                  <svg className="h-3 w-3 text-primary-foreground" fill="none" viewBox="0 0 24 24" stroke="currentColor" strokeWidth={3}>
+                    <path strokeLinecap="round" strokeLinejoin="round" d="M5 13l4 4L19 7" />
+                  </svg>
+                )}
+              </div>
+              <div className="space-y-1">
+                <Label className="font-medium cursor-pointer">
+                  {t('settings.sftp.showHiddenFiles.enable')}
+                </Label>
+                <p className="text-sm text-muted-foreground">
+                  {t('settings.sftp.showHiddenFiles.enableDesc')}
+                </p>
+              </div>
+            </div>
+          </button>
+        </div>
+
         {/* File associations section */}
         <div className="space-y-4">
           <SectionHeader title={t('settings.sftpFileAssociations.title')} />

components/settings/tabs/SettingsSystemTab.tsx

@@ -0,0 +1,180 @@
+/**
+ * Settings System Tab - System information and temp file management
+ */
+import { FolderOpen, HardDrive, RefreshCw, Trash2 } from "lucide-react";
+import { useCallback, useEffect, useState } from "react";
+import { useI18n } from "../../../application/i18n/I18nProvider";
+import { netcattyBridge } from "../../../infrastructure/services/netcattyBridge";
+import { TabsContent } from "../../ui/tabs";
+import { Button } from "../../ui/button";
+
+interface TempDirInfo {
+  path: string;
+  fileCount: number;
+  totalSize: number;
+}
+
+function formatBytes(bytes: number): string {
+  if (bytes === 0) return "0 B";
+  const k = 1024;
+  const sizes = ["B", "KB", "MB", "GB"];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return `${parseFloat((bytes / Math.pow(k, i)).toFixed(2))} ${sizes[i]}`;
+}
+
+const SettingsSystemTab: React.FC = () => {
+  const { t } = useI18n();
+  
+  const [tempDirInfo, setTempDirInfo] = useState<TempDirInfo | null>(null);
+  const [isLoading, setIsLoading] = useState(false);
+  const [isClearing, setIsClearing] = useState(false);
+  const [clearResult, setClearResult] = useState<{ deletedCount: number; failedCount: number } | null>(null);
+
+  const loadTempDirInfo = useCallback(async () => {
+    const bridge = netcattyBridge.get();
+    if (!bridge?.getTempDirInfo) return;
+    
+    setIsLoading(true);
+    try {
+      const info = await bridge.getTempDirInfo();
+      setTempDirInfo(info);
+    } catch (err) {
+      console.error("[SettingsSystemTab] Failed to get temp dir info:", err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+
+  useEffect(() => {
+    loadTempDirInfo();
+  }, [loadTempDirInfo]);
+
+  const handleClearTempFiles = useCallback(async () => {
+    const bridge = netcattyBridge.get();
+    if (!bridge?.clearTempDir) return;
+    
+    setIsClearing(true);
+    setClearResult(null);
+    try {
+      const result = await bridge.clearTempDir();
+      setClearResult(result);
+      // Refresh info after clearing
+      await loadTempDirInfo();
+    } catch (err) {
+      console.error("[SettingsSystemTab] Failed to clear temp dir:", err);
+    } finally {
+      setIsClearing(false);
+    }
+  }, [loadTempDirInfo]);
+
+  const handleOpenTempDir = useCallback(async () => {
+    const bridge = netcattyBridge.get();
+    if (!tempDirInfo?.path || !bridge?.openTempDir) return;
+    await bridge.openTempDir();
+  }, [tempDirInfo]);
+
+  return (
+    <TabsContent
+      value="system"
+      className="data-[state=inactive]:hidden h-full flex flex-col"
+    >
+      <div className="flex-1 overflow-y-auto overflow-x-hidden px-8 py-6">
+        <div className="max-w-2xl space-y-8">
+          {/* Header */}
+          <div>
+            <h2 className="text-xl font-semibold">{t("settings.system.title")}</h2>
+            <p className="text-sm text-muted-foreground mt-1">
+              {t("settings.system.description")}
+            </p>
+          </div>
+
+          {/* Temp Directory Section */}
+          <div className="space-y-4">
+            <div className="flex items-center gap-2">
+              <HardDrive size={18} className="text-muted-foreground" />
+              <h3 className="text-base font-medium">{t("settings.system.tempDirectory")}</h3>
+            </div>
+
+            <div className="bg-muted/30 rounded-lg p-4 space-y-3">
+              {/* Path */}
+              <div className="flex items-start justify-between gap-4">
+                <div className="min-w-0 flex-1">
+                  <p className="text-sm text-muted-foreground">{t("settings.system.location")}</p>
+                  <p className="text-sm font-mono mt-1 break-all">
+                    {isLoading ? "..." : (tempDirInfo?.path ?? "-")}
+                  </p>
+                </div>
+                <Button
+                  variant="ghost"
+                  size="icon"
+                  className="shrink-0"
+                  onClick={handleOpenTempDir}
+                  disabled={!tempDirInfo?.path}
+                  title={t("settings.system.openFolder")}
+                >
+                  <FolderOpen size={16} />
+                </Button>
+              </div>
+
+              {/* Stats */}
+              <div className="flex items-center gap-6 text-sm">
+                <div>
+                  <span className="text-muted-foreground">{t("settings.system.fileCount")}:</span>{" "}
+                  <span className="font-medium">
+                    {isLoading ? "..." : (tempDirInfo?.fileCount ?? 0)}
+                  </span>
+                </div>
+                <div>
+                  <span className="text-muted-foreground">{t("settings.system.totalSize")}:</span>{" "}
+                  <span className="font-medium">
+                    {isLoading ? "..." : formatBytes(tempDirInfo?.totalSize ?? 0)}
+                  </span>
+                </div>
+              </div>
+
+              {/* Actions */}
+              <div className="flex items-center gap-2 pt-2">
+                <Button
+                  variant="outline"
+                  size="sm"
+                  onClick={loadTempDirInfo}
+                  disabled={isLoading}
+                  className="gap-1.5"
+                >
+                  <RefreshCw size={14} className={isLoading ? "animate-spin" : ""} />
+                  {t("settings.system.refresh")}
+                </Button>
+                <Button
+                  variant="outline"
+                  size="sm"
+                  onClick={handleClearTempFiles}
+                  disabled={isClearing || (tempDirInfo?.fileCount ?? 0) === 0}
+                  className="gap-1.5 text-destructive hover:text-destructive hover:bg-destructive/10"
+                >
+                  <Trash2 size={14} />
+                  {isClearing ? t("settings.system.clearing") : t("settings.system.clearTempFiles")}
+                </Button>
+              </div>
+
+              {/* Clear Result */}
+              {clearResult && (
+                <p className="text-sm text-muted-foreground">
+                  {t("settings.system.clearResult", {
+                    deleted: clearResult.deletedCount,
+                    failed: clearResult.failedCount,
+                  })}
+                </p>
+              )}
+            </div>
+
+            <p className="text-xs text-muted-foreground">
+              {t("settings.system.tempDirectoryHint")}
+            </p>
+          </div>
+        </div>
+      </div>
+    </TabsContent>
+  );
+};
+
+export default SettingsSystemTab;

components/settings/tabs/SettingsTerminalTab.tsx

@@ -1,5 +1,5 @@
-import React, { useCallback, useEffect, useState } from "react";
-import { AlertCircle, Check, Minus, Plus, RotateCcw } from "lucide-react";
+import React, { useCallback, useEffect, useState, useMemo } from "react";
+import { AlertCircle, ChevronRight, Minus, Plus, RotateCcw } from "lucide-react";
 import type {
   CursorShape,
   LinkModifier,
@@ -9,65 +9,63 @@ import type {
 } from "../../../domain/models";
 import { DEFAULT_KEYWORD_HIGHLIGHT_RULES } from "../../../domain/models";
 import { useI18n } from "../../../application/i18n/I18nProvider";
-import { TERMINAL_FONTS, MAX_FONT_SIZE, MIN_FONT_SIZE } from "../../../infrastructure/config/fonts";
+import { MAX_FONT_SIZE, MIN_FONT_SIZE, type TerminalFont } from "../../../infrastructure/config/fonts";
 import { TERMINAL_THEMES } from "../../../infrastructure/config/terminalThemes";
 import { cn } from "../../../lib/utils";
 import { Button } from "../../ui/button";
 import { Input } from "../../ui/input";
 import { Label } from "../../ui/label";
 import { SectionHeader, Select, SettingsTabContent, SettingRow, Toggle } from "../settings-ui";
+import { ThemeSelectModal } from "../ThemeSelectModal";
 
-// Helper: render terminal preview
-const renderTerminalPreview = (theme: (typeof TERMINAL_THEMES)[0]) => {
+// Theme preview button component
+const ThemePreviewButton: React.FC<{
+  theme: (typeof TERMINAL_THEMES)[0];
+  onClick: () => void;
+  buttonLabel: string;
+}> = ({ theme, onClick, buttonLabel }) => {
   const c = theme.colors;
-  const lines = [
-    { prompt: "~", cmd: "ssh prod-server", color: c.foreground },
-    { prompt: "prod", cmd: "ls -la", color: c.green },
-    { prompt: "prod", cmd: "cat config.json", color: c.cyan },
-  ];
   return (
-    <div
-      className="font-mono text-[9px] leading-tight p-1.5 rounded overflow-hidden h-full"
-      style={{ backgroundColor: c.background, color: c.foreground }}
+    <button
+      onClick={onClick}
+      className={cn(
+        "w-full flex items-center gap-4 p-3 rounded-lg border bg-card hover:bg-accent/50 transition-all text-left",
+      )}
     >
-      {lines.map((l, i) => (
-        <div key={i} className="flex gap-1 truncate">
-          <span style={{ color: c.blue }}>{l.prompt}</span>
-          <span style={{ color: c.magenta }}>$</span>
-          <span style={{ color: l.color }}>{l.cmd}</span>
+      {/* Theme preview swatch */}
+      <div
+        className="w-20 h-14 rounded-lg flex-shrink-0 flex flex-col justify-center items-start pl-2 gap-0.5 border border-border/50"
+        style={{ backgroundColor: c.background }}
+      >
+        <div className="flex gap-1 items-center">
+          <span className="font-mono text-[8px]" style={{ color: c.green }}>$</span>
+          <span className="font-mono text-[8px]" style={{ color: c.blue }}>ls</span>
+        </div>
+        <div className="flex gap-0.5">
+          <div className="h-1 w-3 rounded-full" style={{ backgroundColor: c.cyan }} />
+          <div className="h-1 w-4 rounded-full" style={{ backgroundColor: c.magenta }} />
+        </div>
+        <div className="flex gap-1 items-center">
+          <span className="font-mono text-[8px]" style={{ color: c.green }}>$</span>
+          <span className="inline-block w-1.5 h-2 animate-pulse" style={{ backgroundColor: c.cursor }} />
         </div>
-      ))}
-      <div className="flex gap-1">
-        <span style={{ color: c.blue }}>~</span>
-        <span style={{ color: c.magenta }}>$</span>
-        <span className="inline-block w-1.5 h-2.5 animate-pulse" style={{ backgroundColor: c.cursor }} />
       </div>
-    </div>
+      
+      {/* Theme info */}
+      <div className="flex-1 min-w-0">
+        <div className="text-sm font-medium">{theme.name}</div>
+        <div className="text-xs text-muted-foreground capitalize">{theme.type}</div>
+      </div>
+      
+      {/* Action button area */}
+      <div className="flex items-center gap-2 text-muted-foreground">
+        <span className="text-xs">{buttonLabel}</span>
+        <ChevronRight size={16} />
+      </div>
+    </button>
   );
 };
 
-const TerminalThemeCard: React.FC<{
-  theme: (typeof TERMINAL_THEMES)[0];
-  active: boolean;
-  onClick: () => void;
-}> = ({ theme, active, onClick }) => (
-  <button
-    onClick={onClick}
-    className={cn(
-      "relative flex flex-col rounded-lg border-2 transition-all overflow-hidden text-left",
-      active ? "border-primary ring-2 ring-primary/20" : "border-border hover:border-primary/50",
-    )}
-  >
-    <div className="h-16">{renderTerminalPreview(theme)}</div>
-    <div className="px-2 py-1.5 text-xs font-medium border-t bg-card">{theme.name}</div>
-    {active && (
-      <div className="absolute top-1 right-1 w-4 h-4 bg-primary rounded-full flex items-center justify-center">
-        <Check size={10} className="text-primary-foreground" />
-      </div>
-    )}
-  </button>
-);
-
 export default function SettingsTerminalTab(props: {
   terminalThemeId: string;
   setTerminalThemeId: (id: string) => void;
@@ -80,6 +78,7 @@ export default function SettingsTerminalTab(props: {
     key: K,
     value: TerminalSettings[K],
   ) => void;
+  availableFonts: TerminalFont[];
 }) {
   const {
     terminalThemeId,
@@ -90,6 +89,7 @@ export default function SettingsTerminalTab(props: {
     setTerminalFontSize,
     terminalSettings,
     updateTerminalSetting,
+    availableFonts,
   } = props;
   const { t } = useI18n();
 
@@ -97,6 +97,12 @@ export default function SettingsTerminalTab(props: {
   const [defaultShell, setDefaultShell] = useState<string>("");
   const [shellValidation, setShellValidation] = useState<{ valid: boolean; message?: string } | null>(null);
   const [dirValidation, setDirValidation] = useState<{ valid: boolean; message?: string } | null>(null);
+  const [themeModalOpen, setThemeModalOpen] = useState(false);
+
+  // Get current selected theme
+  const currentTheme = useMemo(() => {
+    return TERMINAL_THEMES.find(t => t.id === terminalThemeId) || TERMINAL_THEMES[0];
+  }, [terminalThemeId]);
 
   // Fetch default shell on mount
   useEffect(() => {
@@ -182,16 +188,18 @@ export default function SettingsTerminalTab(props: {
   return (
     <SettingsTabContent value="terminal">
       <SectionHeader title={t("settings.terminal.section.theme")} />
-      <div className="grid grid-cols-2 gap-3">
-        {TERMINAL_THEMES.map((t) => (
-          <TerminalThemeCard
-            key={t.id}
-            theme={t}
-            active={terminalThemeId === t.id}
-            onClick={() => setTerminalThemeId(t.id)}
-          />
-        ))}
-      </div>
+      <ThemePreviewButton
+        theme={currentTheme}
+        onClick={() => setThemeModalOpen(true)}
+        buttonLabel={t("settings.terminal.theme.selectButton")}
+      />
+      
+      <ThemeSelectModal
+        open={themeModalOpen}
+        onClose={() => setThemeModalOpen(false)}
+        selectedThemeId={terminalThemeId}
+        onSelect={setTerminalThemeId}
+      />
 
       <SectionHeader title={t("settings.terminal.section.font")} />
       <div className="space-y-0 divide-y divide-border rounded-lg border bg-card px-4">
@@ -201,7 +209,7 @@ export default function SettingsTerminalTab(props: {
         >
           <Select
             value={terminalFontFamilyId}
-            options={TERMINAL_FONTS.map((f) => ({ value: f.id, label: f.name }))}
+            options={availableFonts.map((f) => ({ value: f.id, label: f.name }))}
             onChange={(id) => setTerminalFontFamilyId(id)}
             className="w-40"
           />
@@ -578,6 +586,28 @@ export default function SettingsTerminalTab(props: {
           </div>
         </SettingRow>
       </div>
+
+      <SectionHeader title={t("settings.terminal.section.connection")} />
+      <div className="space-y-0 divide-y divide-border rounded-lg border bg-card px-4">
+        <SettingRow
+          label={t("settings.terminal.connection.keepaliveInterval")}
+          description={t("settings.terminal.connection.keepaliveInterval.desc")}
+        >
+          <Input
+            type="number"
+            min={0}
+            max={3600}
+            value={terminalSettings.keepaliveInterval}
+            onChange={(e) => {
+              const val = parseInt(e.target.value) || 0;
+              if (val >= 0 && val <= 3600) {
+                updateTerminalSetting("keepaliveInterval", val);
+              }
+            }}
+            className="w-24"
+          />
+        </SettingRow>
+      </div>
     </SettingsTabContent>
   );
 }

components/sftp/SftpContext.tsx

@@ -31,6 +31,9 @@ export interface SftpPaneCallbacks {
     onEditFile?: (entry: SftpFileEntry) => void;
     onOpenFile?: (entry: SftpFileEntry) => void;
     onOpenFileWith?: (entry: SftpFileEntry) => void;  // Always show opener dialog
+    onDownloadFile?: (entry: SftpFileEntry) => void;  // Download to local filesystem
+    // External file upload
+    onUploadExternalFiles?: (files: FileList) => Promise<void>;
 }
 
 export interface SftpDragCallbacks {
@@ -91,6 +94,9 @@ export interface SftpContextValue {
     // Callbacks for each side
     leftCallbacks: SftpPaneCallbacks;
     rightCallbacks: SftpPaneCallbacks;
+
+    // Settings
+    showHiddenFiles: boolean;
 }
 
 const SftpContext = createContext<SftpContextValue | null>(null);
@@ -124,12 +130,19 @@ export const useSftpHosts = () => {
     return context.hosts;
 };
 
+// Hook to get showHiddenFiles setting
+export const useSftpShowHiddenFiles = (): boolean => {
+    const context = useSftpContext();
+    return context.showHiddenFiles;
+};
+
 interface SftpContextProviderProps {
     hosts: Host[];
     draggedFiles: { name: string; isDirectory: boolean; side: "left" | "right" }[] | null;
     dragCallbacks: SftpDragCallbacks;
     leftCallbacks: SftpPaneCallbacks;
     rightCallbacks: SftpPaneCallbacks;
+    showHiddenFiles: boolean;
     children: React.ReactNode;
 }
 
@@ -139,6 +152,7 @@ export const SftpContextProvider: React.FC<SftpContextProviderProps> = ({
     dragCallbacks,
     leftCallbacks,
     rightCallbacks,
+    showHiddenFiles,
     children,
 }) => {
     // Memoize the context value to prevent unnecessary re-renders
@@ -150,8 +164,9 @@ export const SftpContextProvider: React.FC<SftpContextProviderProps> = ({
             dragCallbacks,
             leftCallbacks,
             rightCallbacks,
+            showHiddenFiles,
         }),
-        [hosts, draggedFiles, dragCallbacks, leftCallbacks, rightCallbacks],
+        [hosts, draggedFiles, dragCallbacks, leftCallbacks, rightCallbacks, showHiddenFiles],
     );
 
     return <SftpContext.Provider value={value}>{children}</SftpContext.Provider>;

components/sftp/index.ts

@@ -7,7 +7,7 @@
 // Utilities
 export {
 formatBytes,formatDate,
-formatSpeed,formatTransferBytes,getFileIcon,isNavigableDirectory,type ColumnWidths,type SortField,
+formatSpeed,formatTransferBytes,getFileIcon,isNavigableDirectory,isWindowsHiddenFile,filterHiddenFiles,type ColumnWidths,type SortField,
 type SortOrder
 } from './utils';
 
@@ -18,6 +18,7 @@ export {
   useSftpPaneCallbacks,
   useSftpDrag,
   useSftpHosts,
+  useSftpShowHiddenFiles,
   useActiveTabId,
   useIsPaneActive,
   activeTabStore,

components/sftp/utils.ts

@@ -187,3 +187,33 @@ export interface ColumnWidths {
 export const isNavigableDirectory = (entry: SftpFileEntry): boolean => {
     return entry.type === 'directory' || (entry.type === 'symlink' && entry.linkTarget === 'directory');
 };
+
+/**
+ * Check if a file is hidden on Windows
+ * Only applies to local Windows filesystem where the hidden attribute is set
+ * The ".." parent directory entry is never considered hidden
+ * 
+ * Note: On Unix/Linux, there's no system-level hidden file concept.
+ * Dotfiles are just a convention, not actual hidden files, so we don't filter them.
+ */
+export const isWindowsHiddenFile = <T extends { name: string; hidden?: boolean }>(file: T): boolean => {
+    if (file.name === "..") return false;
+    return file.hidden === true;
+};
+
+/**
+ * Filter files based on Windows hidden file visibility setting
+ * Only filters files with the Windows hidden attribute set
+ * Always preserves ".." parent directory entry
+ * 
+ * This setting only affects local Windows filesystem browsing.
+ * On Unix/Linux systems and remote SFTP connections, all files are shown
+ * because there's no system-level hidden file concept (dotfiles are just a convention).
+ */
+export const filterHiddenFiles = <T extends { name: string; hidden?: boolean }>(
+    files: T[],
+    showHiddenFiles: boolean
+): T[] => {
+    if (showHiddenFiles) return files;
+    return files.filter((f) => !isWindowsHiddenFile(f));
+};

components/terminal/ThemeCustomizeModal.tsx

@@ -2,7 +2,7 @@
  * Terminal Theme Customize Modal
  * Left-right split design: list on left, large preview on right
  * Uses React Portal to render at document root for proper z-index
- * 
+ *
  * Features:
  * - Real-time preview: changes are applied immediately to the terminal
  * - Save: persists the current settings
@@ -13,8 +13,9 @@ import React, { useEffect, useMemo, useState, useCallback, useRef, memo } from '
 import { createPortal } from 'react-dom';
 import { Check, Minus, Palette, Plus, Type, X } from 'lucide-react';
 import { useI18n } from '../../application/i18n/I18nProvider';
+import { useAvailableFonts } from '../../application/state/fontStore';
 import { TERMINAL_THEMES, TerminalThemeConfig } from '../../infrastructure/config/terminalThemes';
-import { TERMINAL_FONTS, DEFAULT_FONT_SIZE, MIN_FONT_SIZE, MAX_FONT_SIZE, TerminalFont } from '../../infrastructure/config/fonts';
+import { DEFAULT_FONT_SIZE, MIN_FONT_SIZE, MAX_FONT_SIZE, TerminalFont } from '../../infrastructure/config/fonts';
 import { Button } from '../ui/button';
 import { cn } from '../../lib/utils';
 
@@ -265,6 +266,7 @@ export const ThemeCustomizeModal: React.FC<ThemeCustomizeModalProps> = ({
     onSave,
 }) => {
     const { t } = useI18n();
+    const availableFonts = useAvailableFonts();
     const [activeTab, setActiveTab] = useState<TabType>('theme');
     const [selectedTheme, setSelectedTheme] = useState(currentThemeId);
     const [selectedFont, setSelectedFont] = useState(currentFontFamilyId);
@@ -294,8 +296,8 @@ export const ThemeCustomizeModal: React.FC<ThemeCustomizeModalProps> = ({
     }, [open, currentThemeId, currentFontFamilyId, currentFontSize]);
 
     const currentFont = useMemo(
-        () => TERMINAL_FONTS.find(f => f.id === selectedFont) || TERMINAL_FONTS[0],
-        [selectedFont]
+        (): TerminalFont => availableFonts.find(f => f.id === selectedFont) || availableFonts[0],
+        [selectedFont, availableFonts]
     );
     const currentTheme = useMemo(
         () => TERMINAL_THEMES.find(t => t.id === selectedTheme) || TERMINAL_THEMES[0],
@@ -430,7 +432,7 @@ export const ThemeCustomizeModal: React.FC<ThemeCustomizeModalProps> = ({
                             )}
                             {activeTab === 'font' && (
                                 <div className="space-y-1">
-                                    {TERMINAL_FONTS.map(font => (
+                                    {availableFonts.map(font => (
                                         <FontItem
                                             key={font.id}
                                             font={font}

components/terminal/runtime/createTerminalSessionStarters.ts

@@ -343,6 +343,7 @@ export const createTerminalSessionStarters = (ctx: TerminalSessionStartersContex
           env: termEnv,
           proxy: proxyConfig,
           jumpHosts: jumpHosts.length > 0 ? jumpHosts : undefined,
+          keepaliveInterval: ctx.terminalSettings?.keepaliveInterval,
         });
       };
 

components/terminal/runtime/createXTermRuntime.ts

@@ -10,7 +10,7 @@ import {
   getAppLevelActions,
   getTerminalPassthroughActions,
 } from "../../../application/state/useGlobalHotkeys";
-import { TERMINAL_FONTS } from "../../../infrastructure/config/fonts";
+import { fontStore } from "../../../application/state/fontStore";
 import {
   XTERM_PERFORMANCE_CONFIG,
   type XTermPlatform,
@@ -73,7 +73,7 @@ export type CreateXTermRuntimeContext = {
   ) => void;
   commandBufferRef: RefObject<string>;
   setIsSearchOpen: Dispatch<SetStateAction<boolean>>;
-  
+
   // Serial-specific options
   serialLocalEcho?: boolean;
   serialLineMode?: boolean;
@@ -116,7 +116,8 @@ export const createXTermRuntime = (ctx: CreateXTermRuntimeContext): XTermRuntime
   });
 
   const hostFontId = ctx.host.fontFamily || ctx.fontFamilyId || "menlo";
-  const fontObj = TERMINAL_FONTS.find((f) => f.id === hostFontId) || TERMINAL_FONTS[0];
+  // Use fontStore for font lookup - guarantees non-empty result
+  const fontObj = fontStore.getFontById(hostFontId);
   const fontFamily = fontObj.family;
 
   const effectiveFontSize = ctx.host.fontSize || ctx.fontSize;

domain/models.ts

@@ -378,6 +378,9 @@ export interface TerminalSettings {
   // Local Shell Configuration
   localShell: string; // Path to shell executable (empty = system default)
   localStartDir: string; // Starting directory for local terminal (empty = home directory)
+
+  // SSH Connection
+  keepaliveInterval: number; // Seconds between SSH-level keepalive packets (0 = disabled)
 }
 
 export const DEFAULT_KEYWORD_HIGHLIGHT_RULES: KeywordHighlightRule[] = [
@@ -415,6 +418,7 @@ export const DEFAULT_TERMINAL_SETTINGS: TerminalSettings = {
   keywordHighlightRules: DEFAULT_KEYWORD_HIGHLIGHT_RULES,
   localShell: '', // Empty = use system default
   localStartDir: '', // Empty = use home directory
+  keepaliveInterval: 0, // 0 = disabled (use SSH library defaults)
 };
 
 export interface TerminalTheme {
@@ -469,6 +473,7 @@ export interface RemoteFile {
   lastModified: string;
   linkTarget?: 'file' | 'directory' | null; // For symlinks: the type of the target, or null if broken
   permissions?: string; // rwx format for owner/group/others e.g. "rwxr-xr-x"
+  hidden?: boolean; // Windows hidden attribute (only set for local Windows filesystem)
 }
 
 export type WorkspaceNode =
@@ -508,6 +513,7 @@ export interface SftpFileEntry {
   owner?: string;
   group?: string;
   linkTarget?: 'file' | 'directory' | null; // For symlinks: the type of the target, or null if broken
+  hidden?: boolean; // Windows hidden attribute (only set for local Windows filesystem)
 }
 
 export interface SftpConnection {
@@ -572,6 +578,8 @@ export interface PortForwardingRule {
   remotePort?: number;
   // Host to tunnel through
   hostId?: string;
+  // Auto-start: if true, this rule will automatically start when the app launches
+  autoStart?: boolean;
   // Runtime state
   status: PortForwardingStatus;
   error?: string;

electron-builder.json

@@ -42,6 +42,27 @@
       "NSLocalNetworkUsageDescription": "Netcatty needs local network access for SSH connections"
     }
   },
+  "dmg": {
+    "title": "${productName}",
+    "background": "public/dmg-background.jpg",
+    "iconSize": 100,
+    "iconTextSize": 12,
+    "window": {
+      "width": 672,
+      "height": 500
+    },
+    "contents": [
+      { "x": 150, "y": 158 },
+      { "x": 550, "y": 158, "type": "link", "path": "/Applications" },
+      {
+        "x": 350,
+        "y": 330,
+        "type": "file",
+        "path": "scripts/FixQuarantine.app",
+        "name": "已损坏修复.app"
+      }
+    ]
+  },
   "win": {
     "target": [
       {
@@ -67,15 +88,15 @@
     "target": [
       {
         "target": "AppImage",
-        "arch": ["x64"]
+        "arch": ["x64", "arm64"]
       },
       {
         "target": "deb",
-        "arch": ["x64"]
+        "arch": ["x64", "arm64"]
       },
       {
-        "target": "dir",
-        "arch": ["x64"]
+        "target": "rpm",
+        "arch": ["x64", "arm64"]
       }
     ],
     "category": "Development"

electron/bridges/fileWatcherBridge.cjs

@@ -0,0 +1,379 @@
+/**
+ * File Watcher Bridge - Watches local temp files for changes to sync back to remote
+ * 
+ * This bridge enables auto-sync functionality for files opened with external applications.
+ * When a file is downloaded to temp and opened with an external app, we watch for changes
+ * and automatically upload them back to the remote server.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const crypto = require("node:crypto");
+
+// Map of watchId -> { watcher, localPath, remotePath, sftpId, lastModified, lastSize }
+const activeWatchers = new Map();
+
+// Debounce map to prevent multiple rapid syncs
+const debounceTimers = new Map();
+
+// Map of sftpId -> Set<localPath> to track temp files even without watching
+// This allows cleanup when SFTP session closes, regardless of auto-sync setting
+const tempFilesMap = new Map();
+
+let sftpClients = null;
+let electronModule = null;
+
+/**
+ * Initialize the file watcher bridge with dependencies
+ */
+function init(deps) {
+  sftpClients = deps.sftpClients;
+  electronModule = deps.electronModule;
+}
+
+/**
+ * Register a temp file for cleanup when SFTP session closes
+ * Called regardless of whether auto-sync is enabled
+ */
+function registerTempFile(sftpId, localPath) {
+  if (!tempFilesMap.has(sftpId)) {
+    tempFilesMap.set(sftpId, new Set());
+  }
+  tempFilesMap.get(sftpId).add(localPath);
+  console.log(`[FileWatcher] Registered temp file for cleanup: ${localPath} (session: ${sftpId})`);
+}
+
+/**
+ * Show a system notification for file sync events
+ * Works on macOS, Windows, and Linux
+ */
+function showSystemNotification(title, body) {
+  try {
+    if (!electronModule?.Notification) {
+      console.warn("[FileWatcher] Electron Notification API not available");
+      return;
+    }
+    
+    const { Notification } = electronModule;
+    
+    // Check if notifications are supported
+    if (!Notification.isSupported()) {
+      console.warn("[FileWatcher] System notifications not supported on this platform");
+      return;
+    }
+    
+    const notification = new Notification({
+      title,
+      body,
+      silent: false, // Allow notification sound
+    });
+    
+    notification.show();
+  } catch (err) {
+    console.warn("[FileWatcher] Failed to show system notification:", err.message);
+  }
+}
+
+/**
+ * Start watching a local file for changes
+ * Returns a watchId that can be used to stop watching
+ */
+async function startWatching(event, { localPath, remotePath, sftpId }) {
+  const watchId = `watch-${crypto.randomUUID()}`;
+  
+  console.log(`[FileWatcher] Starting watch: ${localPath} -> ${remotePath}`);
+  
+  // Get initial file stats
+  let lastModified;
+  let lastSize;
+  try {
+    const stat = await fs.promises.stat(localPath);
+    lastModified = stat.mtimeMs;
+    lastSize = stat.size;
+    console.log(`[FileWatcher] Initial file stats: mtime=${lastModified}, size=${lastSize}`);
+  } catch (err) {
+    console.error(`[FileWatcher] Failed to stat file ${localPath}:`, err.message);
+    throw new Error(`Cannot watch file: ${err.message}`);
+  }
+  
+  // Store webContents reference for later notifications
+  const webContents = event.sender;
+  
+  // Use fs.watchFile (polling) instead of fs.watch for better reliability on Windows
+  // fs.watch can miss events when editors use atomic writes (save to temp, then rename)
+  // fs.watchFile polls the file system at regular intervals
+  const pollInterval = 1000; // Check every 1 second
+  
+  fs.watchFile(localPath, { persistent: true, interval: pollInterval }, async (curr, prev) => {
+    console.log(`[FileWatcher] File stat change detected for ${localPath}`);
+    console.log(`[FileWatcher]   Previous: mtime=${prev.mtimeMs}, size=${prev.size}`);
+    console.log(`[FileWatcher]   Current: mtime=${curr.mtimeMs}, size=${curr.size}`);
+    
+    // Check if file was deleted
+    if (curr.nlink === 0) {
+      console.log(`[FileWatcher] File ${localPath} was deleted, stopping watch`);
+      stopWatching(null, { watchId });
+      return;
+    }
+    
+    // Check if file was actually modified
+    if (curr.mtimeMs <= prev.mtimeMs && curr.size === prev.size) {
+      console.log(`[FileWatcher] File unchanged, skipping`);
+      return;
+    }
+    
+    // Debounce rapid changes (e.g., multiple saves in quick succession)
+    const existingTimer = debounceTimers.get(watchId);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+    
+    const timer = setTimeout(async () => {
+      debounceTimers.delete(watchId);
+      await handleFileChange(watchId, webContents);
+    }, 500); // 500ms debounce
+    
+    debounceTimers.set(watchId, timer);
+  });
+  
+  activeWatchers.set(watchId, {
+    watcher: null, // fs.watchFile doesn't return a watcher object
+    localPath,
+    remotePath,
+    sftpId,
+    lastModified,
+    lastSize,
+    webContents,
+    useWatchFile: true, // Flag to indicate we're using fs.watchFile
+  });
+  
+  console.log(`[FileWatcher] Watch started with ID: ${watchId} (using fs.watchFile polling every ${pollInterval}ms)`);
+  return { watchId };
+}
+
+/**
+ * Handle file change event - sync to remote
+ */
+async function handleFileChange(watchId, webContents) {
+  const watchInfo = activeWatchers.get(watchId);
+  if (!watchInfo) return;
+  
+  const { localPath, remotePath, sftpId, lastModified: previousModified, lastSize: previousSize } = watchInfo;
+  
+  // Extract file name once for notifications and logging
+  const fileName = path.basename(remotePath);
+  
+  console.log(`[FileWatcher] File change detected: ${localPath}`);
+  
+  try {
+    // Check if file was actually modified (compare mtime and size)
+    const stat = await fs.promises.stat(localPath);
+    
+    // Skip if neither mtime nor size changed (prevents spurious events on some platforms)
+    if (stat.mtimeMs <= previousModified && stat.size === previousSize) {
+      console.log(`[FileWatcher] File unchanged (mtime and size same), skipping sync`);
+      return;
+    }
+    
+    // Update lastModified and lastSize
+    watchInfo.lastModified = stat.mtimeMs;
+    watchInfo.lastSize = stat.size;
+    
+    // Get the SFTP client
+    if (!sftpClients) {
+      throw new Error("SFTP clients not initialized");
+    }
+    
+    const client = sftpClients.get(sftpId);
+    if (!client) {
+      throw new Error("SFTP session not found or expired");
+    }
+    
+    // Read the local file
+    const content = await fs.promises.readFile(localPath);
+    
+    console.log(`[FileWatcher] Syncing ${content.length} bytes to ${remotePath}`);
+    
+    // Upload to remote
+    await client.put(content, remotePath);
+    
+    console.log(`[FileWatcher] Sync complete: ${remotePath}`);
+    
+    // Show system notification for successful sync
+    showSystemNotification(
+      "Netcatty",
+      `File synced to remote: ${fileName}`
+    );
+    
+    // Notify the renderer about successful sync
+    if (webContents && !webContents.isDestroyed()) {
+      webContents.send("netcatty:filewatch:synced", {
+        watchId,
+        localPath,
+        remotePath,
+        bytesWritten: content.length,
+      });
+    }
+    
+  } catch (err) {
+    console.error(`[FileWatcher] Sync failed for ${localPath}:`, err.message);
+    
+    // Show system notification for sync failure
+    showSystemNotification(
+      "Netcatty",
+      `Failed to sync ${fileName}: ${err.message}`
+    );
+    
+    // Notify the renderer about sync failure
+    if (webContents && !webContents.isDestroyed()) {
+      webContents.send("netcatty:filewatch:error", {
+        watchId,
+        localPath,
+        remotePath,
+        error: err.message,
+      });
+    }
+  }
+}
+
+/**
+ * Stop watching a file and optionally clean up the temp file
+ */
+function stopWatching(event, { watchId, cleanupTempFile = false }) {
+  const watchInfo = activeWatchers.get(watchId);
+  if (!watchInfo) {
+    console.log(`[FileWatcher] Watch ID not found: ${watchId}`);
+    return { success: false };
+  }
+  
+  console.log(`[FileWatcher] Stopping watch: ${watchInfo.localPath}`);
+  
+  // Clear debounce timer if any
+  const timer = debounceTimers.get(watchId);
+  if (timer) {
+    clearTimeout(timer);
+    debounceTimers.delete(watchId);
+  }
+  
+  // Stop the watcher
+  try {
+    if (watchInfo.useWatchFile) {
+      // Using fs.watchFile - need to use fs.unwatchFile
+      fs.unwatchFile(watchInfo.localPath);
+    } else if (watchInfo.watcher) {
+      // Using fs.watch - close the watcher
+      watchInfo.watcher.close();
+    }
+  } catch (err) {
+    console.warn(`[FileWatcher] Error stopping watcher:`, err.message);
+  }
+  
+  // Clean up temp file if requested
+  if (cleanupTempFile && watchInfo.localPath) {
+    cleanupTempFileAsync(watchInfo.localPath);
+  }
+  
+  activeWatchers.delete(watchId);
+  
+  return { success: true };
+}
+
+/**
+ * Asynchronously delete a temp file, logging success and silently handling failures
+ */
+async function cleanupTempFileAsync(filePath) {
+  try {
+    await fs.promises.unlink(filePath);
+    console.log(`[FileWatcher] Temp file cleaned up: ${filePath}`);
+  } catch (err) {
+    // Silently ignore deletion failures (file may be in use or already deleted)
+    console.log(`[FileWatcher] Could not delete temp file (may be in use): ${filePath}`);
+  }
+}
+
+/**
+ * Stop all watchers for a specific SFTP session and clean up temp files
+ * Called when SFTP connection is closed
+ */
+function stopWatchersForSession(sftpId, cleanupTempFiles = true) {
+  let watcherCount = 0;
+  
+  // Stop active watchers
+  for (const [watchId, watchInfo] of activeWatchers.entries()) {
+    if (watchInfo.sftpId === sftpId) {
+      stopWatching(null, { watchId, cleanupTempFile: cleanupTempFiles });
+      watcherCount++;
+    }
+  }
+  if (watcherCount > 0) {
+    console.log(`[FileWatcher] Stopped ${watcherCount} watcher(s) for SFTP session: ${sftpId}`);
+  }
+  
+  // Clean up any registered temp files that weren't being watched
+  if (cleanupTempFiles && tempFilesMap.has(sftpId)) {
+    const tempFiles = tempFilesMap.get(sftpId);
+    let cleanedCount = 0;
+    for (const filePath of tempFiles) {
+      cleanupTempFileAsync(filePath);
+      cleanedCount++;
+    }
+    tempFilesMap.delete(sftpId);
+    if (cleanedCount > 0) {
+      console.log(`[FileWatcher] Queued cleanup for ${cleanedCount} temp file(s) for SFTP session: ${sftpId}`);
+    }
+  }
+}
+
+/**
+ * Get list of active watchers
+ */
+function listWatchers() {
+  const watchers = [];
+  for (const [watchId, info] of activeWatchers.entries()) {
+    watchers.push({
+      watchId,
+      localPath: info.localPath,
+      remotePath: info.remotePath,
+      sftpId: info.sftpId,
+    });
+  }
+  return watchers;
+}
+
+/**
+ * Register IPC handlers for file watching operations
+ */
+function registerHandlers(ipcMain) {
+  console.log("[FileWatcher] Registering IPC handlers");
+  ipcMain.handle("netcatty:filewatch:start", (event, args) => {
+    console.log("[FileWatcher] IPC netcatty:filewatch:start received", args);
+    return startWatching(event, args);
+  });
+  ipcMain.handle("netcatty:filewatch:stop", stopWatching);
+  ipcMain.handle("netcatty:filewatch:list", listWatchers);
+  ipcMain.handle("netcatty:filewatch:registerTempFile", (_event, { sftpId, localPath }) => {
+    registerTempFile(sftpId, localPath);
+    return { success: true };
+  });
+}
+
+/**
+ * Cleanup all watchers on shutdown
+ */
+function cleanup() {
+  console.log(`[FileWatcher] Cleaning up ${activeWatchers.size} watcher(s)`);
+  for (const [watchId] of activeWatchers.entries()) {
+    stopWatching(null, { watchId });
+  }
+}
+
+module.exports = {
+  init,
+  registerHandlers,
+  startWatching,
+  stopWatching,
+  stopWatchersForSession,
+  listWatchers,
+  registerTempFile,
+  cleanup,
+};

electron/bridges/localFsBridge.cjs

@@ -6,14 +6,35 @@
 const fs = require("node:fs");
 const path = require("node:path");
 const os = require("node:os");
+const { execSync } = require("node:child_process");
+
+/**
+ * Check if a file is hidden on Windows using the attrib command
+ * Returns true if the file has the hidden attribute set
+ */
+function isWindowsHiddenFile(filePath) {
+  if (process.platform !== "win32") return false;
+  try {
+    const output = execSync(`attrib "${filePath}"`, { encoding: "utf8" });
+    // attrib output format: "     H  R  filename" where H = hidden, R = read-only, etc.
+    // The attributes appear in the first ~10 characters before the path
+    const attrPart = output.substring(0, output.indexOf(filePath)).toUpperCase();
+    return attrPart.includes("H");
+  } catch (err) {
+    console.warn(`Could not check hidden attribute for ${filePath}:`, err.message);
+    return false;
+  }
+}
 
 /**
  * List files in a local directory
  * Properly handles symlinks by resolving their target type
+ * On Windows, also detects hidden files using the hidden attribute
  */
 async function listLocalDir(event, payload) {
   const dirPath = payload.path;
   const entries = await fs.promises.readdir(dirPath, { withFileTypes: true });
+  const isWindows = process.platform === "win32";
 
   // Stat entries in parallel with a small concurrency limit.
   // Serial stats can be very slow on Windows for large dirs.
@@ -45,12 +66,16 @@ async function listLocalDir(event, payload) {
           type = "file";
         }
         
+        // Check for Windows hidden attribute
+        const hidden = isWindows ? isWindowsHiddenFile(fullPath) : false;
+        
         result[i] = {
           name: entry.name,
           type,
           linkTarget,
           size: `${stat.size} bytes`,
           lastModified: stat.mtime.toISOString(),
+          hidden,
         };
       } catch (err) {
         // Handle broken symlinks - lstat doesn't follow symlinks
@@ -61,12 +86,14 @@ async function listLocalDir(event, payload) {
             const lstat = await fs.promises.lstat(fullPath);
             if (lstat.isSymbolicLink()) {
               // Broken symlink
+              const hidden = isWindows ? isWindowsHiddenFile(fullPath) : false;
               result[i] = {
                 name: brokenEntry.name,
                 type: "symlink",
                 linkTarget: null, // Broken link - target unknown
                 size: `${lstat.size} bytes`,
                 lastModified: lstat.mtime.toISOString(),
+                hidden,
               };
               return;
             }

electron/bridges/sftpBridge.cjs

@@ -10,6 +10,7 @@ const net = require("node:net");
 const SftpClient = require("ssh2-sftp-client");
 const { Client: SSHClient } = require("ssh2");
 const { NetcattyAgent } = require("./netcattyAgent.cjs");
+const fileWatcherBridge = require("./fileWatcherBridge.cjs");
 
 // SFTP clients storage - shared reference passed from main
 let sftpClients = null;
@@ -465,11 +466,23 @@ async function listSftp(event, payload) {
 async function readSftp(event, payload) {
   const client = sftpClients.get(payload.sftpId);
   if (!client) throw new Error("SFTP session not found");
-  
+
   const buffer = await client.get(payload.path);
   return buffer.toString();
 }
 
+/**
+ * Read file as binary (returns ArrayBuffer for binary files like images)
+ */
+async function readSftpBinary(event, payload) {
+  const client = sftpClients.get(payload.sftpId);
+  if (!client) throw new Error("SFTP session not found");
+
+  const buffer = await client.get(payload.path);
+  // Convert Node.js Buffer to ArrayBuffer
+  return buffer.buffer.slice(buffer.byteOffset, buffer.byteOffset + buffer.byteLength);
+}
+
 /**
  * Write file content
  */
@@ -544,12 +557,19 @@ async function writeSftpBinaryWithProgress(event, payload) {
 
 /**
  * Close an SFTP connection
- * Also cleans up any jump host connections if present
+ * Also cleans up any jump host connections and file watchers if present
  */
 async function closeSftp(event, payload) {
   const client = sftpClients.get(payload.sftpId);
   if (!client) return;
   
+  // Stop file watchers and clean up temp files for this SFTP session
+  try {
+    fileWatcherBridge.stopWatchersForSession(payload.sftpId, true);
+  } catch (err) {
+    console.warn("[SFTP] Error stopping file watchers:", err.message);
+  }
+  
   try {
     await client.end();
   } catch (err) {
@@ -641,6 +661,7 @@ function registerHandlers(ipcMain) {
   ipcMain.handle("netcatty:sftp:open", openSftp);
   ipcMain.handle("netcatty:sftp:list", listSftp);
   ipcMain.handle("netcatty:sftp:read", readSftp);
+  ipcMain.handle("netcatty:sftp:readBinary", readSftpBinary);
   ipcMain.handle("netcatty:sftp:write", writeSftp);
   ipcMain.handle("netcatty:sftp:writeBinaryWithProgress", writeSftpBinaryWithProgress);
   ipcMain.handle("netcatty:sftp:close", closeSftp);
@@ -665,6 +686,7 @@ module.exports = {
   openSftp,
   listSftp,
   readSftp,
+  readSftpBinary,
   writeSftp,
   writeSftpBinaryWithProgress,
   closeSftp,

electron/bridges/sshBridge.cjs

@@ -13,7 +13,7 @@ const { NetcattyAgent } = require("./netcattyAgent.cjs");
 const logFile = path.join(require("os").tmpdir(), "netcatty-ssh.log");
 const log = (msg, data) => {
   const line = `[${new Date().toISOString()}] ${msg} ${data ? JSON.stringify(data) : ""}\n`;
-  try { fs.appendFileSync(logFile, line); } catch {}
+  try { fs.appendFileSync(logFile, line); } catch { }
   console.log("[SSH]", msg, data || "");
 };
 
@@ -64,7 +64,7 @@ function createProxySocket(proxy, targetHost, targetPort) {
         }
         const connectRequest = `CONNECT ${targetHost}:${targetPort} HTTP/1.1\r\nHost: ${targetHost}:${targetPort}\r\n${authHeader}\r\n`;
         socket.write(connectRequest);
-        
+
         let response = '';
         const onData = (data) => {
           response += data.toString();
@@ -87,7 +87,7 @@ function createProxySocket(proxy, targetHost, targetPort) {
         // SOCKS5 greeting
         const authMethods = proxy.username && proxy.password ? [0x00, 0x02] : [0x00];
         socket.write(Buffer.from([0x05, authMethods.length, ...authMethods]));
-        
+
         let step = 'greeting';
         const onData = (data) => {
           if (step === 'greeting') {
@@ -144,7 +144,7 @@ function createProxySocket(proxy, targetHost, targetPort) {
             }
           }
         };
-        
+
         const sendConnectRequest = () => {
           // SOCKS5 connect request
           const hostBuf = Buffer.from(targetHost);
@@ -155,7 +155,7 @@ function createProxySocket(proxy, targetHost, targetPort) {
           ]);
           socket.write(request);
         };
-        
+
         socket.on('data', onData);
       });
       socket.on('error', reject);
@@ -172,34 +172,36 @@ async function connectThroughChain(event, options, jumpHosts, targetHost, target
   const sender = event.sender;
   const connections = [];
   let currentSocket = null;
-  
+
   const sendProgress = (hop, total, label, status) => {
     if (!sender.isDestroyed()) {
       sender.send("netcatty:chain:progress", { hop, total, label, status });
     }
   };
-  
+
   try {
     const totalHops = jumpHosts.length;
-    
+
     // Connect through each jump host
     for (let i = 0; i < jumpHosts.length; i++) {
       const jump = jumpHosts[i];
       const isFirst = i === 0;
       const isLast = i === jumpHosts.length - 1;
       const hopLabel = jump.label || `${jump.hostname}:${jump.port || 22}`;
-      
+
       sendProgress(i + 1, totalHops + 1, hopLabel, 'connecting');
-      
+
       const conn = new SSHClient();
-      
+
       // Build connection options
       const connOpts = {
         host: jump.hostname,
         port: jump.port || 22,
         username: jump.username || 'root',
         readyTimeout: 20000, // Reduced from 60s for faster failure detection
-        keepaliveInterval: 10000,
+        // Use user-configured keepalive interval from options (in seconds -> convert to ms)
+        // If 0 or not provided, use 10000ms as default
+        keepaliveInterval: options.keepaliveInterval && options.keepaliveInterval > 0 ? options.keepaliveInterval * 1000 : 10000,
         keepaliveCountMax: 3,
         algorithms: {
           // Prioritize fastest ciphers (GCM modes are hardware-accelerated)
@@ -209,7 +211,7 @@ async function connectThroughChain(event, options, jumpHosts, targetHost, target
           compress: ['none'],
         },
       };
-      
+
       // Auth - support agent (certificate), key, and password fallback
       const hasCertificate =
         typeof jump.certificate === "string" && jump.certificate.trim().length > 0;
@@ -239,7 +241,7 @@ async function connectThroughChain(event, options, jumpHosts, targetHost, target
         if (connOpts.password) order.push("password");
         connOpts.authHandler = order;
       }
-      
+
       // If first hop and proxy is configured, connect through proxy
       if (isFirst && options.proxy) {
         currentSocket = await createProxySocket(options.proxy, jump.hostname, jump.port || 22);
@@ -252,7 +254,7 @@ async function connectThroughChain(event, options, jumpHosts, targetHost, target
         delete connOpts.host;
         delete connOpts.port;
       }
-      
+
       // Connect this hop
       await new Promise((resolve, reject) => {
         conn.on('ready', () => {
@@ -272,9 +274,9 @@ async function connectThroughChain(event, options, jumpHosts, targetHost, target
         console.log(`[Chain] Hop ${i + 1}/${totalHops}: Connecting to ${hopLabel}...`);
         conn.connect(connOpts);
       });
-      
+
       connections.push(conn);
-      
+
       // Determine next target
       let nextHost, nextPort;
       if (isLast) {
@@ -287,7 +289,7 @@ async function connectThroughChain(event, options, jumpHosts, targetHost, target
         nextHost = nextJump.hostname;
         nextPort = nextJump.port || 22;
       }
-      
+
       // Create forward stream to next hop
       console.log(`[Chain] Hop ${i + 1}/${totalHops}: Forwarding from ${hopLabel} to ${nextHost}:${nextPort}...`);
       sendProgress(i + 1, totalHops + 1, hopLabel, 'forwarding');
@@ -303,17 +305,17 @@ async function connectThroughChain(event, options, jumpHosts, targetHost, target
         });
       });
     }
-    
+
     // Return the final forwarded stream and all connections for cleanup
-    return { 
-      socket: currentSocket, 
+    return {
+      socket: currentSocket,
       connections,
-      sendProgress 
+      sendProgress
     };
   } catch (err) {
     // Cleanup on error
     for (const conn of connections) {
-      try { conn.end(); } catch {}
+      try { conn.end(); } catch { }
     }
     throw err;
   }
@@ -330,7 +332,7 @@ async function startSSHSession(event, options) {
   const cols = options.cols || 80;
   const rows = options.rows || 24;
   const sender = event.sender;
-  
+
   const sendProgress = (hop, total, label, status) => {
     if (!sender.isDestroyed()) {
       sender.send("netcatty:chain:progress", { hop, total, label, status });
@@ -341,13 +343,13 @@ async function startSSHSession(event, options) {
     const conn = new SSHClient();
     let chainConnections = [];
     let connectionSocket = null;
-    
+
     // Determine if we have jump hosts
     const jumpHosts = options.jumpHosts || [];
     const hasJumpHosts = jumpHosts.length > 0;
     const hasProxy = !!options.proxy;
     const totalHops = jumpHosts.length + 1; // +1 for final target
-    
+
     // Build base connection options for final target
     const connectOpts = {
       host: options.hostname,
@@ -355,7 +357,9 @@ async function startSSHSession(event, options) {
       username: options.username || "root",
       // `readyTimeout` covers the entire connection + authentication flow in ssh2.
       readyTimeout: 20000, // Fast failure for non-interactive auth
-      keepaliveInterval: 10000,
+      // Use user-configured keepalive interval (in seconds -> convert to ms)
+      // If 0 or not provided, use 10000ms as default
+      keepaliveInterval: options.keepaliveInterval && options.keepaliveInterval > 0 ? options.keepaliveInterval * 1000 : 10000,
       keepaliveCountMax: 3,
       algorithms: {
         // Prioritize fastest ciphers (GCM modes are hardware-accelerated)
@@ -378,7 +382,7 @@ async function startSSHSession(event, options) {
       hasPassword: !!options.password,
       hasEffectivePassphrase: !!effectivePassphrase,
     });
-    
+
     log("Auth configuration", {
       hasCertificate,
       keySource: options.keySource,
@@ -433,25 +437,25 @@ async function startSSHSession(event, options) {
     // Handle chain/proxy connections
     if (hasJumpHosts) {
       const chainResult = await connectThroughChain(
-        event, 
-        options, 
-        jumpHosts, 
-        options.hostname, 
+        event,
+        options,
+        jumpHosts,
+        options.hostname,
         options.port || 22
       );
       connectionSocket = chainResult.socket;
       chainConnections = chainResult.connections;
-      
+
       connectOpts.sock = connectionSocket;
       delete connectOpts.host;
       delete connectOpts.port;
-      
+
       sendProgress(totalHops, totalHops, options.hostname, 'connecting');
     } else if (hasProxy) {
       sendProgress(1, 1, options.hostname, 'connecting');
       connectionSocket = await createProxySocket(
-        options.proxy, 
-        options.hostname, 
+        options.proxy,
+        options.hostname,
         options.port || 22
       );
       connectOpts.sock = connectionSocket;
@@ -466,7 +470,7 @@ async function startSSHSession(event, options) {
         if (hasJumpHosts || hasProxy) {
           sendProgress(totalHops, totalHops, options.hostname, 'connected');
         }
-        
+
         conn.shell(
           {
             term: "xterm-256color",
@@ -474,7 +478,7 @@ async function startSSHSession(event, options) {
             rows,
           },
           {
-            env: { 
+            env: {
               LANG: resolveLangFromCharset(options.charset),
               COLORTERM: "truecolor",
               ...(options.env || {}),
@@ -484,7 +488,7 @@ async function startSSHSession(event, options) {
             if (err) {
               conn.end();
               for (const c of chainConnections) {
-                try { c.end(); } catch {}
+                try { c.end(); } catch { }
               }
               reject(err);
               return;
@@ -503,7 +507,7 @@ async function startSSHSession(event, options) {
             let flushTimeout = null;
             const FLUSH_INTERVAL = 8; // ms - flush every 8ms for ~120fps equivalent
             const MAX_BUFFER_SIZE = 16384; // 16KB - flush immediately if buffer gets too large
-            
+
             const flushBuffer = () => {
               if (dataBuffer.length > 0) {
                 const contents = event.sender;
@@ -512,7 +516,7 @@ async function startSSHSession(event, options) {
               }
               flushTimeout = null;
             };
-            
+
             const bufferData = (data) => {
               dataBuffer += data;
               // Immediate flush for large chunks
@@ -547,7 +551,7 @@ async function startSSHSession(event, options) {
               sessions.delete(sessionId);
               conn.end();
               for (const c of chainConnections) {
-                try { c.end(); } catch {}
+                try { c.end(); } catch { }
               }
             });
 
@@ -565,28 +569,28 @@ async function startSSHSession(event, options) {
 
       conn.on("error", (err) => {
         const contents = event.sender;
-        
+
         const isAuthError = err.message?.toLowerCase().includes('authentication') ||
-                           err.message?.toLowerCase().includes('auth') ||
-                           err.message?.toLowerCase().includes('password') ||
-                           err.level === 'client-authentication';
-        
+          err.message?.toLowerCase().includes('auth') ||
+          err.message?.toLowerCase().includes('password') ||
+          err.level === 'client-authentication';
+
         // Use log instead of error for auth failures (normal fallback scenario)
         if (isAuthError) {
           console.log(`${logPrefix} ${options.hostname} auth failed:`, err.message);
-          safeSend(contents, "netcatty:auth:failed", { 
-            sessionId, 
+          safeSend(contents, "netcatty:auth:failed", {
+            sessionId,
             error: err.message,
-            hostname: options.hostname 
+            hostname: options.hostname
           });
         } else {
           console.error(`${logPrefix} ${options.hostname} error:`, err.message);
         }
-        
+
         safeSend(contents, "netcatty:exit", { sessionId, exitCode: 1, error: err.message });
         sessions.delete(sessionId);
         for (const c of chainConnections) {
-          try { c.end(); } catch {}
+          try { c.end(); } catch { }
         }
         reject(err);
       });
@@ -598,7 +602,7 @@ async function startSSHSession(event, options) {
         safeSend(contents, "netcatty:exit", { sessionId, exitCode: 1, error: err.message });
         sessions.delete(sessionId);
         for (const c of chainConnections) {
-          try { c.end(); } catch {}
+          try { c.end(); } catch { }
         }
         reject(err);
       });
@@ -608,7 +612,7 @@ async function startSSHSession(event, options) {
         safeSend(contents, "netcatty:exit", { sessionId, exitCode: 0 });
         sessions.delete(sessionId);
         for (const c of chainConnections) {
-          try { c.end(); } catch {}
+          try { c.end(); } catch { }
         }
       });
 
@@ -727,11 +731,11 @@ async function execCommand(event, payload) {
  */
 async function generateKeyPair(event, options) {
   const { type, bits, comment } = options;
-  
+
   try {
     let keyType;
     let keyBits = bits;
-    
+
     switch (type) {
       case 'ED25519':
         keyType = 'ed25519';
@@ -747,15 +751,15 @@ async function generateKeyPair(event, options) {
         keyBits = bits || 4096;
         break;
     }
-    
+
     const result = sshUtils.generateKeyPairSync(keyType, {
       bits: keyBits,
       comment: comment || 'netcatty-generated-key',
     });
-    
+
     const privateKey = result.private;
     const publicKey = result.public;
-    
+
     return {
       success: true,
       privateKey,
@@ -779,9 +783,9 @@ async function startSSHSessionWrapper(event, options) {
     return await startSSHSession(event, options);
   } catch (err) {
     const isAuthError = err.message?.toLowerCase().includes('authentication') ||
-                       err.message?.toLowerCase().includes('auth') ||
-                       err.level === 'client-authentication';
-    
+      err.message?.toLowerCase().includes('auth') ||
+      err.level === 'client-authentication';
+
     if (isAuthError) {
       // Re-throw with a clean error to avoid Electron printing full stack trace
       // The frontend will handle this as a normal auth failure for fallback
@@ -796,50 +800,74 @@ async function startSSHSessionWrapper(event, options) {
 
 /**
  * Get current working directory from an active SSH session
- * This sends 'pwd' to the shell and captures the output
+ * This sends 'pwd' to the existing shell stream and captures the output
+ * using unique markers to identify the command output boundaries
  */
 async function getSessionPwd(event, payload) {
   const { sessionId } = payload;
   const session = sessions.get(sessionId);
-  
+
   if (!session || !session.stream || !session.conn) {
     return { success: false, error: 'Session not found or not connected' };
   }
-  
+
   return new Promise((resolve) => {
-    const conn = session.conn;
+    const stream = session.stream;
+    const marker = `__PWD_${Date.now()}__`;
     const timeout = setTimeout(() => {
+      stream.removeListener('data', onData);
       resolve({ success: false, error: 'Timeout getting pwd' });
     }, 3000);
-    
-    // Use exec on the existing connection to run pwd
-    conn.exec('pwd', (err, stream) => {
-      if (err) {
-        clearTimeout(timeout);
-        resolve({ success: false, error: err.message });
-        return;
-      }
-      
-      let stdout = '';
-      stream.on('data', (data) => {
-        stdout += data.toString();
-      });
-      
-      stream.on('close', () => {
-        clearTimeout(timeout);
-        const cwd = stdout.trim().split(/\r?\n/).pop()?.trim();
-        if (cwd && cwd.startsWith('/')) {
-          resolve({ success: true, cwd });
-        } else {
-          resolve({ success: false, error: 'Invalid pwd output' });
+
+    let buffer = '';
+
+    const onData = (data) => {
+      const str = data.toString();
+      buffer += str;
+
+      // We need to find the ACTUAL output markers, not the command echo
+      // The command echo looks like: echo '__PWD_xxx__S' && pwd && echo '__PWD_xxx__E'
+      // The actual output looks like: __PWD_xxx__S\n/path/to/dir\n__PWD_xxx__E
+      // 
+      // We look for the marker at the START of a line (after newline) to avoid the echo
+      const startMarkerRegex = new RegExp(`(?:^|[\\r\\n])${marker}S[\\r\\n]+`);
+      const endMarkerRegex = new RegExp(`[\\r\\n]${marker}E(?:[\\r\\n]|$)`);
+
+      const startMatch = buffer.match(startMarkerRegex);
+      const endMatch = buffer.match(endMarkerRegex);
+
+      if (startMatch && endMatch) {
+        const startIdx = buffer.indexOf(startMatch[0]) + startMatch[0].length;
+        const endIdx = buffer.indexOf(endMatch[0]);
+
+        if (startIdx <= endIdx) {
+          clearTimeout(timeout);
+          stream.removeListener('data', onData);
+
+          const pwdOutput = buffer.slice(startIdx, endIdx).trim();
+          console.log('[getSessionPwd] pwdOutput:', JSON.stringify(pwdOutput));
+
+          // The pwd output should be a valid absolute path
+          if (pwdOutput && pwdOutput.startsWith('/')) {
+            console.log('[getSessionPwd] Success, cwd:', pwdOutput);
+            resolve({ success: true, cwd: pwdOutput });
+          } else {
+            console.log('[getSessionPwd] Failed - invalid path:', pwdOutput);
+            resolve({ success: false, error: 'Invalid pwd output' });
+          }
         }
-      });
-      
-      stream.on('error', (err) => {
-        clearTimeout(timeout);
-        resolve({ success: false, error: err.message });
-      });
-    });
+      }
+    };
+
+    stream.on('data', onData);
+
+    // Send pwd command with short unique markers
+    // Using 'S' and 'E' as suffixes to make markers shorter
+    // After the command, send ANSI escape sequences to clear the output lines:
+    // \x1b[1A = move cursor up 1 line, \x1b[2K = clear entire line
+    // Clear 4 lines: the command echo, START marker, pwd output, and END marker
+    const clearLines = '\\x1b[1A\\x1b[2K\\x1b[1A\\x1b[2K\\x1b[1A\\x1b[2K\\x1b[1A\\x1b[2K';
+    stream.write(` echo '${marker}S' && pwd && echo '${marker}E' && printf '${clearLines}'\n`);
   });
 }
 

electron/bridges/tempDirBridge.cjs

@@ -0,0 +1,183 @@
+/**
+ * Temp Directory Bridge - Manages Netcatty's dedicated temp directory
+ * 
+ * All temporary files (SFTP downloads, etc.) are stored in a dedicated
+ * Netcatty folder within the system temp directory for easier cleanup.
+ */
+
+const fs = require("node:fs");
+const path = require("node:path");
+const os = require("node:os");
+
+// Netcatty temp directory name
+const NETCATTY_TEMP_DIR_NAME = "Netcatty";
+
+// Cached temp directory path
+let cachedTempDir = null;
+
+/**
+ * Get the Netcatty temp directory path
+ * Creates the directory if it doesn't exist
+ */
+function getTempDir() {
+  if (cachedTempDir) {
+    // Verify it still exists
+    try {
+      if (fs.existsSync(cachedTempDir)) {
+        return cachedTempDir;
+      }
+    } catch {
+      // Directory was deleted, recreate it
+    }
+  }
+  
+  const systemTempDir = os.tmpdir();
+  const netcattyTempDir = path.join(systemTempDir, NETCATTY_TEMP_DIR_NAME);
+  
+  try {
+    if (!fs.existsSync(netcattyTempDir)) {
+      fs.mkdirSync(netcattyTempDir, { recursive: true });
+      console.log(`[TempDir] Created Netcatty temp directory: ${netcattyTempDir}`);
+    }
+    cachedTempDir = netcattyTempDir;
+    return netcattyTempDir;
+  } catch (err) {
+    console.error(`[TempDir] Failed to create temp directory:`, err.message);
+    // Fallback to system temp dir
+    return systemTempDir;
+  }
+}
+
+/**
+ * Ensure the temp directory exists (call on app startup)
+ */
+function ensureTempDir() {
+  const tempDir = getTempDir();
+  console.log(`[TempDir] Netcatty temp directory: ${tempDir}`);
+  return tempDir;
+}
+
+/**
+ * Get temp directory info (path, size, file count)
+ */
+async function getTempDirInfo() {
+  const tempDir = getTempDir();
+  
+  try {
+    const files = await fs.promises.readdir(tempDir);
+    let totalSize = 0;
+    let fileCount = 0;
+    
+    for (const file of files) {
+      try {
+        const filePath = path.join(tempDir, file);
+        const stat = await fs.promises.stat(filePath);
+        if (stat.isFile()) {
+          totalSize += stat.size;
+          fileCount++;
+        }
+      } catch {
+        // Skip files that can't be stat'd
+      }
+    }
+    
+    return {
+      path: tempDir,
+      totalSize,
+      fileCount,
+    };
+  } catch (err) {
+    console.error(`[TempDir] Failed to get temp dir info:`, err.message);
+    return {
+      path: tempDir,
+      totalSize: 0,
+      fileCount: 0,
+    };
+  }
+}
+
+/**
+ * Clear all files in the temp directory
+ * Returns the number of files deleted
+ */
+async function clearTempDir() {
+  const tempDir = getTempDir();
+  let deletedCount = 0;
+  let failedCount = 0;
+  
+  try {
+    const files = await fs.promises.readdir(tempDir);
+    
+    for (const file of files) {
+      try {
+        const filePath = path.join(tempDir, file);
+        const stat = await fs.promises.stat(filePath);
+        
+        if (stat.isFile()) {
+          await fs.promises.unlink(filePath);
+          deletedCount++;
+          console.log(`[TempDir] Deleted: ${file}`);
+        } else if (stat.isDirectory()) {
+          // Recursively delete subdirectories
+          await fs.promises.rm(filePath, { recursive: true, force: true });
+          deletedCount++;
+          console.log(`[TempDir] Deleted directory: ${file}`);
+        }
+      } catch (err) {
+        failedCount++;
+        console.log(`[TempDir] Could not delete ${file}: ${err.message}`);
+      }
+    }
+    
+    console.log(`[TempDir] Cleanup complete: ${deletedCount} deleted, ${failedCount} failed`);
+    return { deletedCount, failedCount };
+  } catch (err) {
+    console.error(`[TempDir] Failed to clear temp dir:`, err.message);
+    return { deletedCount: 0, failedCount: 0, error: err.message };
+  }
+}
+
+/**
+ * Generate a unique temp file path for a given filename
+ */
+function getTempFilePath(fileName) {
+  const tempDir = getTempDir();
+  const timestamp = Date.now();
+  const safeFileName = fileName.replace(/[<>:"/\\|?*]/g, "_");
+  return path.join(tempDir, `${timestamp}_${safeFileName}`);
+}
+
+/**
+ * Register IPC handlers
+ */
+function registerHandlers(ipcMain, shell) {
+  ipcMain.handle("netcatty:tempdir:getInfo", async () => {
+    return getTempDirInfo();
+  });
+  
+  ipcMain.handle("netcatty:tempdir:clear", async () => {
+    return clearTempDir();
+  });
+  
+  ipcMain.handle("netcatty:tempdir:getPath", () => {
+    return getTempDir();
+  });
+  
+  ipcMain.handle("netcatty:tempdir:open", async () => {
+    const tempDir = getTempDir();
+    if (shell?.openPath) {
+      await shell.openPath(tempDir);
+      return { success: true };
+    }
+    return { success: false };
+  });
+}
+
+module.exports = {
+  getTempDir,
+  ensureTempDir,
+  getTempDirInfo,
+  clearTempDir,
+  getTempFilePath,
+  registerHandlers,
+};

electron/main.cjs

@@ -36,7 +36,7 @@ try {
   electronModule = require("electron");
 }
 
-const { app, BrowserWindow, Menu, protocol } = electronModule || {};
+const { app, BrowserWindow, Menu, protocol, shell } = electronModule || {};
 if (!app || !BrowserWindow) {
   throw new Error("Failed to load Electron runtime. Ensure the app is launched with the Electron binary.");
 }
@@ -76,6 +76,8 @@ const githubAuthBridge = require("./bridges/githubAuthBridge.cjs");
 const googleAuthBridge = require("./bridges/googleAuthBridge.cjs");
 const onedriveAuthBridge = require("./bridges/onedriveAuthBridge.cjs");
 const cloudSyncBridge = require("./bridges/cloudSyncBridge.cjs");
+const fileWatcherBridge = require("./bridges/fileWatcherBridge.cjs");
+const tempDirBridge = require("./bridges/tempDirBridge.cjs");
 const windowManager = require("./bridges/windowManager.cjs");
 
 // GPU settings
@@ -359,6 +361,10 @@ const registerBridges = (win) => {
   sftpBridge.init(deps);
   transferBridge.init(deps);
   terminalBridge.init(deps);
+  fileWatcherBridge.init(deps);
+
+  // Initialize temp directory (synchronously)
+  tempDirBridge.ensureTempDir();
 
   // Register all IPC handlers
   sshBridge.registerHandlers(ipcMain);
@@ -372,6 +378,8 @@ const registerBridges = (win) => {
   googleAuthBridge.registerHandlers(ipcMain, electronModule);
   onedriveAuthBridge.registerHandlers(ipcMain, electronModule);
   cloudSyncBridge.registerHandlers(ipcMain);
+  fileWatcherBridge.registerHandlers(ipcMain);
+  tempDirBridge.registerHandlers(ipcMain, shell);
 
   // Settings window handler
   ipcMain.handle("netcatty:settings:open", async () => {
@@ -470,33 +478,94 @@ const registerBridges = (win) => {
 
   // Open a file with a specific application
   ipcMain.handle("netcatty:openWithApplication", async (_event, { filePath, appPath }) => {
-    const { shell, spawn } = electronModule;
     const { spawn: cpSpawn } = require("node:child_process");
     
-    if (process.platform === "darwin") {
-      // On macOS, use 'open' command with -a flag for specific app
-      cpSpawn("open", ["-a", appPath, filePath], { detached: true, stdio: "ignore" }).unref();
-    } else if (process.platform === "win32") {
-      // On Windows, just spawn the exe with the file as argument
-      cpSpawn(appPath, [filePath], { detached: true, stdio: "ignore", shell: true }).unref();
-    } else {
-      // On Linux, spawn the app with the file
-      cpSpawn(appPath, [filePath], { detached: true, stdio: "ignore" }).unref();
-    }
+    console.log(`[Main] Opening file with application:`);
+    console.log(`[Main]   File: ${filePath}`);
+    console.log(`[Main]   App: ${appPath}`);
+    console.log(`[Main]   Platform: ${process.platform}`);
     
-    return true;
+    try {
+      let child;
+      if (process.platform === "darwin") {
+        // On macOS, use 'open' command with -a flag for specific app
+        const args = ["-a", appPath, filePath];
+        console.log(`[Main]   Command: open ${args.join(' ')}`);
+        child = cpSpawn("open", args, { detached: true, stdio: "pipe" });
+      } else if (process.platform === "win32") {
+        // On Windows, use cmd /c start to properly handle paths with spaces
+        // The empty string "" as window title is required when the first arg has quotes
+        const args = ["/c", "start", "\"\"", `"${appPath}"`, `"${filePath}"`];
+        console.log(`[Main]   Command: cmd ${args.join(' ')}`);
+        child = cpSpawn("cmd", args, { detached: true, stdio: "pipe", windowsVerbatimArguments: true });
+      } else {
+        // On Linux, spawn the app with the file
+        console.log(`[Main]   Command: ${appPath} ${filePath}`);
+        child = cpSpawn(appPath, [filePath], { detached: true, stdio: "pipe" });
+      }
+      
+      // Log any errors from the child process
+      child.on("error", (err) => {
+        console.error(`[Main] Failed to start application:`, err.message);
+      });
+      
+      child.stderr?.on("data", (data) => {
+        // On Windows, stderr may be encoded in GBK/CP936, try to decode
+        if (process.platform === "win32") {
+          try {
+            // Try decoding as GBK (code page 936) for Chinese Windows
+            const { TextDecoder } = require("node:util");
+            const decoder = new TextDecoder("gbk");
+            const decoded = decoder.decode(data);
+            console.log(`[Main] Application stderr: ${decoded}`);
+          } catch {
+            // Fallback to hex dump if decoding fails
+            console.log(`[Main] Application stderr (hex): ${data.toString("hex")}`);
+          }
+        } else {
+          console.error(`[Main] Application stderr:`, data.toString());
+        }
+      });
+      
+      child.on("exit", (code, signal) => {
+        // On Windows, many apps (like Notepad++) pass the file to an existing instance
+        // and immediately exit with code 1, this is normal behavior
+        if (code !== 0 && code !== null) {
+          if (process.platform === "win32") {
+            console.log(`[Main] Application exited with code: ${code}, signal: ${signal} (this may be normal for single-instance apps)`);
+          } else {
+            console.warn(`[Main] Application exited with code: ${code}, signal: ${signal}`);
+          }
+        } else {
+          console.log(`[Main] Application started successfully`);
+        }
+      });
+      
+      child.unref();
+      return true;
+    } catch (err) {
+      console.error(`[Main] Error opening file with application:`, err);
+      throw err;
+    }
   });
 
   // Download SFTP file to temp and return local path
   ipcMain.handle("netcatty:sftp:downloadToTemp", async (_event, { sftpId, remotePath, fileName }) => {
+    console.log(`[Main] Downloading SFTP file to temp:`);
+    console.log(`[Main]   SFTP ID: ${sftpId}`);
+    console.log(`[Main]   Remote path: ${remotePath}`);
+    console.log(`[Main]   File name: ${fileName}`);
+    
     const client = require("./bridges/sftpBridge.cjs");
-    const tempDir = os.tmpdir();
-    const tempFileName = `netcatty_${Date.now()}_${fileName}`;
-    const localPath = path.join(tempDir, tempFileName);
+    // Use tempDirBridge for dedicated Netcatty temp directory
+    const localPath = await tempDirBridge.getTempFilePath(fileName);
+    
+    console.log(`[Main]   Local temp path: ${localPath}`);
     
     // Get the sftp client and download file
     const sftpClients = client.getSftpClients ? client.getSftpClients() : null;
     if (!sftpClients) {
+      console.log(`[Main]   Using fallback readSftp method`);
       // Fallback: use readSftp and write to temp file
       const content = await client.readSftp(null, { sftpId, path: remotePath });
       if (typeof content === "string") {
@@ -504,18 +573,42 @@ const registerBridges = (win) => {
       } else {
         await fs.promises.writeFile(localPath, content);
       }
+      console.log(`[Main]   File downloaded successfully (fallback)`);
       return localPath;
     }
     
     const sftpClient = sftpClients.get(sftpId);
     if (!sftpClient) {
+      console.error(`[Main]   SFTP session not found: ${sftpId}`);
       throw new Error("SFTP session not found");
     }
     
     await sftpClient.fastGet(remotePath, localPath);
+    console.log(`[Main]   File downloaded successfully`);
     return localPath;
   });
 
+  // Delete a temp file (for cleanup when editors close)
+  ipcMain.handle("netcatty:deleteTempFile", async (_event, { filePath }) => {
+    try {
+      // Only allow deleting files in Netcatty temp directory for security
+      const netcattyTempDir = tempDirBridge.getTempDir();
+      const resolvedPath = path.resolve(filePath);
+      if (!resolvedPath.startsWith(netcattyTempDir)) {
+        console.warn(`[Main] Refused to delete file outside Netcatty temp dir: ${filePath}`);
+        return { success: false };
+      }
+      
+      await fs.promises.unlink(resolvedPath);
+      console.log(`[Main] Temp file deleted: ${filePath}`);
+      return { success: true };
+    } catch (err) {
+      // Silently handle failures (file may be in use or already deleted)
+      console.log(`[Main] Could not delete temp file: ${filePath} (${err.message})`);
+      return { success: false };
+    }
+  });
+
   console.log('[Main] All bridges registered successfully');
 };
 

electron/preload.cjs

@@ -198,6 +198,30 @@ ipcRenderer.on("netcatty:portforward:status", (_event, payload) => {
   }
 });
 
+// File watcher listeners (for auto-sync feature)
+const fileWatchSyncedListeners = new Set();
+const fileWatchErrorListeners = new Set();
+
+ipcRenderer.on("netcatty:filewatch:synced", (_event, payload) => {
+  fileWatchSyncedListeners.forEach((cb) => {
+    try {
+      cb(payload);
+    } catch (err) {
+      console.error("File watch synced callback failed", err);
+    }
+  });
+});
+
+ipcRenderer.on("netcatty:filewatch:error", (_event, payload) => {
+  fileWatchErrorListeners.forEach((cb) => {
+    try {
+      cb(payload);
+    } catch (err) {
+      console.error("File watch error callback failed", err);
+    }
+  });
+});
+
 const api = {
   startSSHSession: async (options) => {
     const result = await ipcRenderer.invoke("netcatty:start", options);
@@ -271,6 +295,9 @@ const api = {
   readSftp: async (sftpId, path) => {
     return ipcRenderer.invoke("netcatty:sftp:read", { sftpId, path });
   },
+  readSftpBinary: async (sftpId, path) => {
+    return ipcRenderer.invoke("netcatty:sftp:readBinary", { sftpId, path });
+  },
   writeSftp: async (sftpId, path, content) => {
     return ipcRenderer.invoke("netcatty:sftp:write", { sftpId, path, content });
   },
@@ -512,6 +539,38 @@ const api = {
     ipcRenderer.invoke("netcatty:openWithApplication", { filePath, appPath }),
   downloadSftpToTemp: (sftpId, remotePath, fileName) =>
     ipcRenderer.invoke("netcatty:sftp:downloadToTemp", { sftpId, remotePath, fileName }),
+  
+  // File watcher for auto-sync feature
+  startFileWatch: (localPath, remotePath, sftpId) =>
+    ipcRenderer.invoke("netcatty:filewatch:start", { localPath, remotePath, sftpId }),
+  stopFileWatch: (watchId, cleanupTempFile = false) =>
+    ipcRenderer.invoke("netcatty:filewatch:stop", { watchId, cleanupTempFile }),
+  listFileWatches: () =>
+    ipcRenderer.invoke("netcatty:filewatch:list"),
+  registerTempFile: (sftpId, localPath) =>
+    ipcRenderer.invoke("netcatty:filewatch:registerTempFile", { sftpId, localPath }),
+  onFileWatchSynced: (cb) => {
+    fileWatchSyncedListeners.add(cb);
+    return () => fileWatchSyncedListeners.delete(cb);
+  },
+  onFileWatchError: (cb) => {
+    fileWatchErrorListeners.add(cb);
+    return () => fileWatchErrorListeners.delete(cb);
+  },
+  
+  // Temp file cleanup
+  deleteTempFile: (filePath) =>
+    ipcRenderer.invoke("netcatty:deleteTempFile", { filePath }),
+  
+  // Temp directory management
+  getTempDirInfo: () =>
+    ipcRenderer.invoke("netcatty:tempdir:getInfo"),
+  clearTempDir: () =>
+    ipcRenderer.invoke("netcatty:tempdir:clear"),
+  getTempDirPath: () =>
+    ipcRenderer.invoke("netcatty:tempdir:getPath"),
+  openTempDir: () =>
+    ipcRenderer.invoke("netcatty:tempdir:open"),
 };
 
 // Merge with existing netcatty (if any) to avoid stale objects on hot reload

global.d.ts

@@ -61,6 +61,8 @@ interface NetcattySSHOptions {
   proxy?: NetcattyProxyConfig;
   // Jump hosts (bastion chain)
   jumpHosts?: NetcattyJumpHost[];
+  // SSH-level keepalive interval in seconds (0 = disabled)
+  keepaliveInterval?: number;
 }
 
 interface SftpStatResult {
@@ -415,6 +417,23 @@ interface NetcattyBridge {
   selectApplication?(): Promise<{ path: string; name: string } | null>;
   openWithApplication?(filePath: string, appPath: string): Promise<boolean>;
   downloadSftpToTemp?(sftpId: string, remotePath: string, fileName: string): Promise<string>;
+  
+  // File watcher for auto-sync feature
+  startFileWatch?(localPath: string, remotePath: string, sftpId: string): Promise<{ watchId: string }>;
+  stopFileWatch?(watchId: string, cleanupTempFile?: boolean): Promise<{ success: boolean }>;
+  listFileWatches?(): Promise<Array<{ watchId: string; localPath: string; remotePath: string; sftpId: string }>>;
+  registerTempFile?(sftpId: string, localPath: string): Promise<{ success: boolean }>;
+  onFileWatchSynced?(cb: (payload: { watchId: string; localPath: string; remotePath: string; bytesWritten: number }) => void): () => void;
+  onFileWatchError?(cb: (payload: { watchId: string; localPath: string; remotePath: string; error: string }) => void): () => void;
+  
+  // Temp file cleanup
+  deleteTempFile?(filePath: string): Promise<{ success: boolean }>;
+  
+  // Temp directory management
+  getTempDirInfo?(): Promise<{ path: string; fileCount: number; totalSize: number }>;
+  clearTempDir?(): Promise<{ deletedCount: number; failedCount: number; error?: string }>;
+  getTempDirPath?(): Promise<string>;
+  openTempDir?(): Promise<{ success: boolean }>;
 }
 
 interface Window {

infrastructure/config/fonts.ts

@@ -30,7 +30,7 @@ const CJK_FALLBACK_FONTS = [
 
 const CJK_FALLBACK_STACK = CJK_FALLBACK_FONTS.join(', ');
 
-const withCjkFallback = (family: string) => {
+export const withCjkFallback = (family: string) => {
   const trimmed = family.trim();
   if (!CJK_FALLBACK_STACK) return trimmed;
   // Avoid double-appending if a custom stack already includes one of these fonts.

infrastructure/config/storageKeys.ts

@@ -40,6 +40,8 @@ export const STORAGE_KEY_SFTP_FILE_ASSOCIATIONS = 'netcatty_sftp_file_associatio
 
 // SFTP Settings
 export const STORAGE_KEY_SFTP_DOUBLE_CLICK_BEHAVIOR = 'netcatty_sftp_double_click_behavior_v1';
+export const STORAGE_KEY_SFTP_AUTO_SYNC = 'netcatty_sftp_auto_sync_v1';
+export const STORAGE_KEY_SFTP_SHOW_HIDDEN_FILES = 'netcatty_sftp_show_hidden_files_v1';
 
 // Archived legacy key records that are no longer supported by the app (e.g. biometric/WebAuthn/FIDO2 experiments).
 export const STORAGE_KEY_LEGACY_KEYS = 'netcatty_legacy_keys_v1';

infrastructure/services/portForwardingService.ts

@@ -14,11 +14,84 @@ export interface PortForwardingConnection {
   status: 'inactive' | 'connecting' | 'active' | 'error';
   error?: string;
   unsubscribe?: () => void;
+  // Reconnect state
+  reconnectAttempts?: number;
+  reconnectTimeoutId?: ReturnType<typeof setTimeout>;
 }
 
 // Map to track active connections
 const activeConnections = new Map<string, PortForwardingConnection>();
 
+// Reconnect configuration
+const MAX_RECONNECT_ATTEMPTS = 5;
+const RECONNECT_DELAY_MS = 3000; // 3 seconds between reconnection attempts
+
+// Callbacks for auto-reconnect - will be set by the state hook
+let reconnectCallback: ((
+  ruleId: string,
+  onStatusChange: (status: PortForwardingRule['status'], error?: string) => void
+) => Promise<{ success: boolean; error?: string }>) | null = null;
+
+/**
+ * Set the reconnect callback (called by state hook to enable auto-reconnect)
+ */
+export const setReconnectCallback = (
+  callback: typeof reconnectCallback
+): void => {
+  reconnectCallback = callback;
+};
+
+/**
+ * Clear any pending reconnect for a rule
+ */
+export const clearReconnectTimer = (ruleId: string): void => {
+  const conn = activeConnections.get(ruleId);
+  if (conn?.reconnectTimeoutId) {
+    clearTimeout(conn.reconnectTimeoutId);
+    conn.reconnectTimeoutId = undefined;
+  }
+};
+
+/**
+ * Helper function to schedule a reconnection attempt
+ * Returns true if a reconnect was scheduled, false otherwise
+ */
+const scheduleReconnectIfNeeded = (
+  ruleId: string,
+  enableReconnect: boolean,
+  onStatusChange: (status: PortForwardingRule['status'], error?: string) => void,
+): boolean => {
+  if (!enableReconnect || !reconnectCallback) {
+    return false;
+  }
+
+  const currentConn = activeConnections.get(ruleId);
+  const attempts = (currentConn?.reconnectAttempts ?? 0) + 1;
+
+  if (attempts <= MAX_RECONNECT_ATTEMPTS) {
+    logger.info(`[PortForwardingService] Scheduling reconnect ${attempts}/${MAX_RECONNECT_ATTEMPTS}`);
+
+    if (currentConn) {
+      currentConn.reconnectAttempts = attempts;
+      currentConn.reconnectTimeoutId = setTimeout(() => {
+        if (reconnectCallback) {
+          reconnectCallback(ruleId, onStatusChange);
+        }
+      }, RECONNECT_DELAY_MS);
+    }
+
+    onStatusChange('connecting', `Reconnecting (${attempts}/${MAX_RECONNECT_ATTEMPTS})...`);
+    return true;
+  }
+
+  logger.warn(`[PortForwardingService] Max reconnect attempts (${MAX_RECONNECT_ATTEMPTS}) reached for rule ${ruleId}`);
+  // Reset reconnect attempts
+  if (currentConn) {
+    currentConn.reconnectAttempts = 0;
+  }
+  return false;
+};
+
 /**
  * Get active connection info for a rule
  */
@@ -106,15 +179,20 @@ export const syncWithBackend = async (): Promise<void> => {
 
 /**
  * Start a port forwarding tunnel
+ * @param enableReconnect - If true, will automatically attempt to reconnect on disconnect
  */
 export const startPortForward = async (
   rule: PortForwardingRule,
   host: Host,
   keys: { id: string; privateKey: string }[],
-  onStatusChange: (status: PortForwardingRule['status'], error?: string) => void
+  onStatusChange: (status: PortForwardingRule['status'], error?: string) => void,
+  enableReconnect = false
 ): Promise<{ success: boolean; error?: string }> => {
   const bridge = netcattyBridge.get();
   
+  // Clear any existing reconnect timer
+  clearReconnectTimer(rule.id);
+  
   if (!bridge?.startPortForward) {
     // Fallback for browser/dev mode - simulate the connection
     logger.warn('[PortForwardingService] Backend not available, simulating connection...');
@@ -141,15 +219,26 @@ export const startPortForward = async (
         conn.status = status;
         conn.error = error;
       }
+      
+      // Handle auto-reconnect on error/disconnect
+      if (status === 'error') {
+        const reconnectScheduled = scheduleReconnectIfNeeded(rule.id, enableReconnect, onStatusChange);
+        if (reconnectScheduled) {
+          return;
+        }
+      }
+      
       onStatusChange(status, error ?? undefined);
     });
     
-    // Store connection info
+    // Store connection info (preserve reconnect attempts if this is a reconnect)
+    const existingConn = activeConnections.get(rule.id);
     activeConnections.set(rule.id, {
       ruleId: rule.id,
       tunnelId,
       status: 'connecting',
       unsubscribe,
+      reconnectAttempts: existingConn?.reconnectAttempts ?? 0,
     });
     
     onStatusChange('connecting');
@@ -170,16 +259,35 @@ export const startPortForward = async (
     });
     
     if (!result.success) {
+      // Check if we should attempt reconnect
+      const reconnectScheduled = scheduleReconnectIfNeeded(rule.id, enableReconnect, onStatusChange);
+      if (reconnectScheduled) {
+        return { success: false, error: result.error };
+      }
+      
       activeConnections.delete(rule.id);
       unsubscribe?.();
       onStatusChange('error', result.error);
       return { success: false, error: result.error };
     }
     
+    // Reset reconnect attempts on successful connection
+    const conn = activeConnections.get(rule.id);
+    if (conn) {
+      conn.reconnectAttempts = 0;
+    }
+    
     return { success: true };
     
   } catch (err) {
     const error = err instanceof Error ? err.message : 'Unknown error';
+    
+    // Check if we should attempt reconnect
+    const reconnectScheduled = scheduleReconnectIfNeeded(rule.id, enableReconnect, onStatusChange);
+    if (reconnectScheduled) {
+      return { success: false, error };
+    }
+    
     onStatusChange('error', error);
     activeConnections.delete(rule.id);
     return { success: false, error };
@@ -196,6 +304,9 @@ export const stopPortForward = async (
   const bridge = netcattyBridge.get();
   const conn = activeConnections.get(ruleId);
   
+  // Clear any pending reconnect timer
+  clearReconnectTimer(ruleId);
+  
   if (!conn) {
     onStatusChange('inactive');
     return { success: true };
@@ -249,16 +360,19 @@ export const isBackendAvailable = (): boolean => {
 export const stopAllPortForwards = async (): Promise<void> => {
   const bridge = netcattyBridge.get();
   
-  for (const [_ruleId, conn] of activeConnections) {
-	    try {
-	      if (bridge?.stopPortForward) {
-	        await bridge.stopPortForward(conn.tunnelId);
-	      }
-	      conn.unsubscribe?.();
-	    } catch (err) {
-	      logger.warn(`[PortForwardingService] Failed to stop tunnel ${conn.tunnelId}:`, err);
-	    }
-	  }
+  for (const [ruleId, conn] of activeConnections) {
+    // Clear any pending reconnect timer
+    clearReconnectTimer(ruleId);
+    
+    try {
+      if (bridge?.stopPortForward) {
+        await bridge.stopPortForward(conn.tunnelId);
+      }
+      conn.unsubscribe?.();
+    } catch (err) {
+      logger.warn(`[PortForwardingService] Failed to stop tunnel ${conn.tunnelId}:`, err);
+    }
+  }
   
   activeConnections.clear();
 };
@@ -299,4 +413,6 @@ export default {
   getPortForwardStatus,
   isBackendAvailable,
   stopAllPortForwards,
+  setReconnectCallback,
+  clearReconnectTimer,
 };

lib/localFonts.ts

@@ -0,0 +1,127 @@
+import { TerminalFont, withCjkFallback } from "../infrastructure/config/fonts"
+
+/**
+ * Type definition for Local Font Access API
+ * @see https://developer.mozilla.org/en-US/docs/Web/API/Local_Font_Access_API
+ */
+interface LocalFontData {
+    family: string;
+}
+
+/**
+ * Known monospace font families that don't follow naming conventions.
+ * These are popular programming/terminal fonts that should be included.
+ */
+const KNOWN_MONOSPACE_FONTS = new Set([
+    // Popular programming fonts
+    'iosevka',
+    'hack',
+    'consolas',
+    'menlo',
+    'monaco',
+    'inconsolata',
+    'mononoki',
+    'fantasque sans mono',
+    'anonymous pro',
+    'liberation mono',
+    'dejavu sans mono',
+    'droid sans mono',
+    'ubuntu mono',
+    'roboto mono',
+    'source code pro',
+    'fira code',
+    'fira mono',
+    'jetbrains mono',
+    'cascadia code',
+    'cascadia mono',
+    'victor mono',
+    'ibm plex mono',
+    'sf mono',
+    'operator mono',
+    'input mono',
+    'pragmata pro',
+    'berkeley mono',
+    'monaspace',
+    'geist mono',
+    'comic mono',
+    'courier',
+    'courier new',
+    'lucida console',
+    'pt mono',
+    'overpass mono',
+    'space mono',
+    'go mono',
+    'noto sans mono',
+    'sarasa mono',
+    'maple mono',
+]);
+
+/**
+ * Suffix indicators that suggest a font is monospace
+ */
+const MONO_SUFFIX_INDICATORS = ['mono', 'monospace', 'code', 'terminal', 'console'];
+
+/**
+ * Checks if a font family name indicates a monospace font.
+ * Uses both known font list and suffix matching for comprehensive detection.
+ */
+function isMonospaceFont(familyName: string): boolean {
+    const familyLower = familyName.toLowerCase().trim();
+    
+    // Check against known monospace fonts (exact or partial match)
+    for (const knownFont of KNOWN_MONOSPACE_FONTS) {
+        if (familyLower === knownFont || familyLower.startsWith(knownFont + ' ')) {
+            return true;
+        }
+    }
+    
+    // Check suffix indicators with word boundary
+    return MONO_SUFFIX_INDICATORS.some(indicator => {
+        return (
+            familyLower === indicator ||
+            familyLower.endsWith(' ' + indicator) ||
+            familyLower.endsWith('-' + indicator) ||
+            familyLower.includes(' ' + indicator + ' ')
+        );
+    });
+}
+
+/**
+ * Queries local monospace fonts from the system using the Font Access API.
+ * Returns an empty array if the API is not available or permission is denied.
+ */
+export async function getMonospaceFonts(): Promise<TerminalFont[]> {
+    // Check if the Font Access API is available
+    if (typeof window === "undefined" || !("queryLocalFonts" in window)) {
+        return [];
+    }
+
+    try {
+        const queryLocalFonts = (window as unknown as { queryLocalFonts: () => Promise<LocalFontData[]> }).queryLocalFonts;
+        const fonts = await queryLocalFonts();
+
+        // Filter monospace fonts using robust word boundary matching
+        const monoFonts = fonts.filter(f => isMonospaceFont(f.family));
+
+        // Deduplicate by family name (API may return multiple entries per family)
+        const uniqueFamilies = new Set<string>();
+        const dedupedFonts = monoFonts.filter(f => {
+            if (uniqueFamilies.has(f.family)) return false;
+            uniqueFamilies.add(f.family);
+            return true;
+        });
+
+        // Map to TerminalFont structure with CJK fallback applied
+        return dedupedFonts.map(f => ({
+            id: f.family,
+            name: f.family,
+            family: withCjkFallback(f.family + ', monospace'),
+            description: `Local font: ${f.family}`,
+            category: 'monospace' as const,
+        }));
+    } catch (error) {
+        // Handle permission denied or other errors gracefully
+        console.warn('Failed to query local fonts:', error);
+        return [];
+    }
+}

package.json

@@ -1,10 +1,11 @@
 {
   "name": "netcatty",
   "description": "Netcatty is a modern SSH manager and terminal app with host grouping, SFTP, keychain, port forwarding, and a rich UI.",
+  "homepage": "https://github.com/binaricat/Netcatty",
   "private": true,
   "version": "0.0.0",
   "type": "module",
-  "author": "binaricat",
+  "author": "binaricat <support@netcatty.com>",
   "license": "GPL-3.0-or-later",
   "main": "electron/main.cjs",
   "scripts": {

scripts/FixQuarantine.app/Contents/Info.plist

@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+  <dict>
+    <key>CFBundleDevelopmentRegion</key>
+    <string>en</string>
+    <key>CFBundleDisplayName</key>
+    <string>Fix Quarantine</string>
+    <key>CFBundleExecutable</key>
+    <string>FixQuarantine</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.netcatty.fixquarantine</string>
+    <key>CFBundleInfoDictionaryVersion</key>
+    <string>6.0</string>
+    <key>CFBundleName</key>
+    <string>Fix Quarantine</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>CFBundleShortVersionString</key>
+    <string>1.0.0</string>
+    <key>CFBundleVersion</key>
+    <string>1.0.0</string>
+    <key>CFBundleIconFile</key>
+    <string>FixQuarantine.icns</string>
+    <key>LSMinimumSystemVersion</key>
+    <string>10.13</string>
+  </dict>
+</plist>

scripts/FixQuarantine.app/Contents/MacOS/FixQuarantine

@@ -0,0 +1,17 @@
+#!/bin/bash
+set -e
+
+APP_PATH="/Applications/Netcatty.app"
+
+if [ ! -d "$APP_PATH" ]; then
+  /usr/bin/osascript <<'EOF'
+    display alert "Netcatty.app not found" message "Drag Netcatty.app into /Applications, then run this tool again." as critical buttons {"OK"} default button "OK"
+EOF
+  exit 1
+fi
+
+/usr/bin/osascript <<'EOF'
+  do shell script "xattr -dr com.apple.quarantine /Applications/Netcatty.app" with administrator privileges
+EOF
+
+open "$APP_PATH"

scripts/gen_icns.sh

@@ -0,0 +1,10 @@
+# 1) 准备一张 1024x1024 PNG，例如放在 public/dmg-fix-icon.png
+# 2) 生成 iconset 并转 icns
+ICONSET="scripts/fixquarantine.iconset"
+mkdir -p "$ICONSET"
+for size in 16 32 128 256 512; do
+  sips -z "$size" "$size" public/dmg-fix-icon.png --out "$ICONSET/icon_${size}x${size}.png" >/dev/null
+  sips -z "$((size*2))" "$((size*2))" public/dmg-fix-icon.png --out "$ICONSET/icon_${size}x${size}@2x.png" >/dev/null
+done
+iconutil -c icns "$ICONSET" -o scripts/FixQuarantine.app/Contents/Resources/FixQuarantine.icns
+rm -rf $ICONSET