mirror of
https://github.com/binaricat/Netcatty.git
synced 2026-11-17 13:01:24 +00:00
Introduces reusable SSH identities for authentication, allowing hosts to reference centralized identity records containing usernames, passwords, and key/certificate associations. Updates connection, SFTP, terminal, and sync logic to resolve credentials via identities, improving credential management and reuse. Enhances UI for identity selection, editing, and deletion. Updates localization for related identity and credential strings. Ensures identities are included in sync and vault persistence. Streamlines SSH connection attempts by preferring key-based auth with fallback to password, both for host and identity-based authentication. Facilitates safer, more flexible credential management across the application.
590 lines
21 KiB
TypeScript
Executable File
590 lines
21 KiB
TypeScript
Executable File
// Proxy configuration for SSH connections
|
|
export type ProxyType = 'http' | 'socks5';
|
|
// UI locale identifier, stored in settings and used for i18n (e.g., "en", "zh-CN").
|
|
export type UILanguage = string;
|
|
|
|
export interface ProxyConfig {
|
|
type: ProxyType;
|
|
host: string;
|
|
port: number;
|
|
username?: string;
|
|
password?: string;
|
|
}
|
|
|
|
// Host chain configuration for jump host / bastion connections
|
|
export interface HostChainConfig {
|
|
hostIds: string[]; // Array of host IDs in order (first = closest to client)
|
|
}
|
|
|
|
// Environment variable for SSH session
|
|
export interface EnvVar {
|
|
name: string;
|
|
value: string;
|
|
}
|
|
|
|
// Protocol type for connections
|
|
export type HostProtocol = 'ssh' | 'telnet' | 'mosh' | 'local';
|
|
|
|
// Per-protocol configuration
|
|
export interface ProtocolConfig {
|
|
protocol: HostProtocol;
|
|
port: number;
|
|
enabled: boolean;
|
|
// Mosh-specific
|
|
moshServerPath?: string;
|
|
// Protocol-specific theme override
|
|
theme?: string;
|
|
}
|
|
|
|
export interface Host {
|
|
id: string;
|
|
label: string;
|
|
hostname: string;
|
|
port: number;
|
|
username: string;
|
|
// Optional reference to a reusable identity (username + auth) stored in Keychain.
|
|
identityId?: string;
|
|
group?: string;
|
|
tags: string[];
|
|
os: 'linux' | 'windows' | 'macos';
|
|
identityFileId?: string; // Reference to SSHKey
|
|
protocol?: 'ssh' | 'telnet' | 'local'; // Default/primary protocol
|
|
password?: string;
|
|
authMethod?: 'password' | 'key' | 'certificate';
|
|
agentForwarding?: boolean;
|
|
createdAt?: number; // Timestamp when host was created
|
|
startupCommand?: string;
|
|
hostChaining?: string; // Deprecated: use hostChain instead
|
|
proxy?: string; // Deprecated: use proxyConfig instead
|
|
proxyConfig?: ProxyConfig; // New structured proxy configuration
|
|
hostChain?: HostChainConfig; // New structured host chain configuration
|
|
envVars?: string; // Deprecated: use environmentVariables instead
|
|
environmentVariables?: EnvVar[]; // Structured environment variables
|
|
charset?: string;
|
|
moshEnabled?: boolean;
|
|
moshServerPath?: string; // Custom mosh-server path (e.g., /usr/local/bin/mosh-server)
|
|
theme?: string;
|
|
fontFamily?: string; // Terminal font family for this host
|
|
fontSize?: number; // Terminal font size for this host (pt)
|
|
distro?: string; // detected distro id (e.g., ubuntu, debian)
|
|
// Multi-protocol support
|
|
protocols?: ProtocolConfig[]; // Multiple protocol configurations
|
|
telnetPort?: number; // Telnet-specific port (for quick access)
|
|
telnetEnabled?: boolean; // Is Telnet enabled for this host
|
|
telnetUsername?: string; // Telnet-specific username
|
|
telnetPassword?: string; // Telnet-specific password
|
|
}
|
|
|
|
export type KeyType = 'RSA' | 'ECDSA' | 'ED25519';
|
|
export type KeySource = 'generated' | 'imported';
|
|
export type KeyCategory = 'key' | 'certificate' | 'identity';
|
|
export type IdentityAuthMethod = 'password' | 'key' | 'certificate';
|
|
|
|
export interface SSHKey {
|
|
id: string;
|
|
label: string;
|
|
type: KeyType;
|
|
keySize?: number; // RSA: 4096/2048/1024, ECDSA: 521/384/256
|
|
privateKey: string;
|
|
publicKey?: string;
|
|
certificate?: string;
|
|
passphrase?: string; // encrypted or stored securely
|
|
savePassphrase?: boolean;
|
|
source: KeySource;
|
|
category: KeyCategory;
|
|
created: number;
|
|
}
|
|
|
|
// Identity combines username with authentication method
|
|
export interface Identity {
|
|
id: string;
|
|
label: string;
|
|
username: string;
|
|
authMethod: IdentityAuthMethod;
|
|
password?: string; // For password auth
|
|
keyId?: string; // Reference to SSHKey for key/certificate auth
|
|
created: number;
|
|
}
|
|
|
|
export interface Snippet {
|
|
id: string;
|
|
label: string;
|
|
command: string; // Multi-line script
|
|
tags?: string[];
|
|
package?: string; // package path
|
|
targets?: string[]; // host ids
|
|
}
|
|
|
|
export interface TerminalLine {
|
|
type: 'input' | 'output' | 'error' | 'system';
|
|
content: string;
|
|
directory?: string;
|
|
timestamp: number;
|
|
}
|
|
|
|
export interface ChatMessage {
|
|
role: 'user' | 'model';
|
|
text: string;
|
|
}
|
|
|
|
export interface GroupNode {
|
|
name: string;
|
|
path: string;
|
|
children: Record<string, GroupNode>;
|
|
hosts: Host[];
|
|
}
|
|
|
|
export interface SyncConfig {
|
|
gistId: string;
|
|
githubToken: string;
|
|
gistToken?: string; // Alias for githubToken (deprecated, use githubToken)
|
|
lastSync?: number;
|
|
}
|
|
|
|
// Keyboard Shortcuts / Hotkeys
|
|
export type HotkeyScheme = 'disabled' | 'mac' | 'pc';
|
|
|
|
export interface KeyBinding {
|
|
id: string;
|
|
action: string;
|
|
label: string;
|
|
mac: string; // e.g., '⌘+1', '⌘+⌥+arrows'
|
|
pc: string; // e.g., 'Ctrl+1', 'Ctrl+Alt+arrows'
|
|
category: 'tabs' | 'terminal' | 'navigation' | 'app';
|
|
}
|
|
|
|
// User's custom key bindings - only stores overrides from defaults
|
|
export type CustomKeyBindings = Record<string, { mac?: string; pc?: string }>;
|
|
|
|
// Parse a key string like "⌘ + Shift + K" or "Ctrl + Alt + T" into normalized form
|
|
export const parseKeyCombo = (keyStr: string): { modifiers: string[]; key: string } | null => {
|
|
if (!keyStr || keyStr === 'Disabled') return null;
|
|
const parts = keyStr.split('+').map(p => p.trim());
|
|
const key = parts.pop() || '';
|
|
return { modifiers: parts, key };
|
|
};
|
|
|
|
// Convert keyboard event to a key string
|
|
export const keyEventToString = (e: KeyboardEvent, isMac: boolean): string => {
|
|
const parts: string[] = [];
|
|
|
|
if (isMac) {
|
|
if (e.metaKey) parts.push('⌘');
|
|
if (e.ctrlKey) parts.push('⌃');
|
|
if (e.altKey) parts.push('⌥');
|
|
if (e.shiftKey) parts.push('Shift');
|
|
} else {
|
|
if (e.ctrlKey) parts.push('Ctrl');
|
|
if (e.altKey) parts.push('Alt');
|
|
if (e.shiftKey) parts.push('Shift');
|
|
if (e.metaKey) parts.push('Win');
|
|
}
|
|
|
|
// Get the key name
|
|
let keyName = e.key;
|
|
// Normalize special keys
|
|
if (keyName === ' ') keyName = 'Space';
|
|
else if (keyName === 'ArrowUp') keyName = '↑';
|
|
else if (keyName === 'ArrowDown') keyName = '↓';
|
|
else if (keyName === 'ArrowLeft') keyName = '←';
|
|
else if (keyName === 'ArrowRight') keyName = '→';
|
|
else if (keyName === 'Escape') keyName = 'Esc';
|
|
else if (keyName === 'Backspace') keyName = '⌫';
|
|
else if (keyName === 'Delete') keyName = 'Del';
|
|
else if (keyName === 'Enter') keyName = '↵';
|
|
else if (keyName === 'Tab') keyName = '⇥';
|
|
else if (keyName.length === 1) keyName = keyName.toUpperCase();
|
|
|
|
// Don't include modifier keys themselves
|
|
if (['Meta', 'Control', 'Alt', 'Shift'].includes(e.key)) {
|
|
return parts.join(' + ');
|
|
}
|
|
|
|
parts.push(keyName);
|
|
return parts.join(' + ');
|
|
};
|
|
|
|
// Check if a keyboard event matches a key binding string
|
|
export const matchesKeyBinding = (e: KeyboardEvent, keyStr: string, isMac: boolean): boolean => {
|
|
if (!keyStr || keyStr === 'Disabled') return false;
|
|
|
|
// Handle range patterns like "[1...9]"
|
|
if (keyStr.includes('[1...9]')) {
|
|
const basePattern = keyStr.replace('[1...9]', '');
|
|
const key = e.key;
|
|
if (!/^[1-9]$/.test(key)) return false;
|
|
// Check modifiers match the base pattern
|
|
const testStr = basePattern + key;
|
|
return matchesKeyBinding(e, testStr.trim(), isMac);
|
|
}
|
|
|
|
// Handle arrow key patterns like "arrows"
|
|
if (keyStr.includes('arrows')) {
|
|
const basePattern = keyStr.replace('arrows', '');
|
|
const key = e.key;
|
|
// Check if it's an arrow key
|
|
if (!['ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight'].includes(key)) return false;
|
|
// Map arrow key to symbol for matching
|
|
const arrowSymbol = key === 'ArrowUp' ? '↑'
|
|
: key === 'ArrowDown' ? '↓'
|
|
: key === 'ArrowLeft' ? '←'
|
|
: '→';
|
|
// Check modifiers match the base pattern
|
|
const testStr = basePattern + arrowSymbol;
|
|
return matchesKeyBinding(e, testStr.trim(), isMac);
|
|
}
|
|
|
|
const parsed = parseKeyCombo(keyStr);
|
|
if (!parsed) return false;
|
|
|
|
const { modifiers, key } = parsed;
|
|
|
|
// Check modifiers
|
|
if (isMac) {
|
|
const needMeta = modifiers.includes('⌘');
|
|
const needCtrl = modifiers.includes('⌃');
|
|
const needAlt = modifiers.includes('⌥');
|
|
const needShift = modifiers.includes('Shift');
|
|
|
|
if (e.metaKey !== needMeta) return false;
|
|
if (e.ctrlKey !== needCtrl) return false;
|
|
if (e.altKey !== needAlt) return false;
|
|
if (e.shiftKey !== needShift) return false;
|
|
} else {
|
|
const needCtrl = modifiers.includes('Ctrl');
|
|
const needAlt = modifiers.includes('Alt');
|
|
const needShift = modifiers.includes('Shift');
|
|
const needMeta = modifiers.includes('Win');
|
|
|
|
if (e.ctrlKey !== needCtrl) return false;
|
|
if (e.altKey !== needAlt) return false;
|
|
if (e.shiftKey !== needShift) return false;
|
|
if (e.metaKey !== needMeta) return false;
|
|
}
|
|
|
|
// Check key
|
|
let eventKey = e.key;
|
|
if (eventKey === ' ') eventKey = 'Space';
|
|
else if (eventKey === 'ArrowUp') eventKey = '↑';
|
|
else if (eventKey === 'ArrowDown') eventKey = '↓';
|
|
else if (eventKey === 'ArrowLeft') eventKey = '←';
|
|
else if (eventKey === 'ArrowRight') eventKey = '→';
|
|
else if (eventKey === 'Escape') eventKey = 'Esc';
|
|
else if (eventKey === '[') eventKey = '[';
|
|
else if (eventKey === ']') eventKey = ']';
|
|
|
|
return eventKey.toLowerCase() === key.toLowerCase();
|
|
};
|
|
|
|
export const DEFAULT_KEY_BINDINGS: KeyBinding[] = [
|
|
// Tab Management
|
|
{ id: 'switch-tab-1-9', action: 'switchToTab', label: 'Switch to Tab [1...9]', mac: '⌘ + [1...9]', pc: 'Ctrl + [1...9]', category: 'tabs' },
|
|
{ id: 'next-tab', action: 'nextTab', label: 'Next Tab', mac: '⌘ + Shift + ]', pc: 'Ctrl + Tab', category: 'tabs' },
|
|
{ id: 'prev-tab', action: 'prevTab', label: 'Previous Tab', mac: '⌘ + Shift + [', pc: 'Ctrl + Shift + Tab', category: 'tabs' },
|
|
{ id: 'close-tab', action: 'closeTab', label: 'Close Tab', mac: '⌘ + W', pc: 'Ctrl + W', category: 'tabs' },
|
|
{ id: 'new-tab', action: 'newTab', label: 'New Local Tab', mac: '⌘ + T', pc: 'Ctrl + T', category: 'tabs' },
|
|
|
|
// Terminal Operations
|
|
{ id: 'copy', action: 'copy', label: 'Copy from Terminal', mac: '⌘ + C', pc: 'Ctrl + Shift + C', category: 'terminal' },
|
|
{ id: 'paste', action: 'paste', label: 'Paste to Terminal', mac: '⌘ + V', pc: 'Ctrl + Shift + V', category: 'terminal' },
|
|
{ id: 'select-all', action: 'selectAll', label: 'Select All in Terminal', mac: '⌘ + A', pc: 'Ctrl + Shift + A', category: 'terminal' },
|
|
{ id: 'clear-buffer', action: 'clearBuffer', label: 'Clear Terminal Buffer', mac: '⌘ + K', pc: 'Ctrl + L', category: 'terminal' },
|
|
{ id: 'search-terminal', action: 'searchTerminal', label: 'Open Terminal Search', mac: '⌘ + F', pc: 'Ctrl + Shift + F', category: 'terminal' },
|
|
|
|
// Navigation / Split View
|
|
{ id: 'move-focus', action: 'moveFocus', label: 'Move focus between Split View panes', mac: '⌘ + ⌥ + arrows', pc: 'Ctrl + Alt + arrows', category: 'navigation' },
|
|
{ id: 'split-horizontal', action: 'splitHorizontal', label: 'Split Horizontal', mac: '⌘ + D', pc: 'Ctrl + Shift + D', category: 'navigation' },
|
|
{ id: 'split-vertical', action: 'splitVertical', label: 'Split Vertical', mac: '⌘ + Shift + D', pc: 'Ctrl + Shift + E', category: 'navigation' },
|
|
|
|
// App Features
|
|
{ id: 'open-hosts', action: 'openHosts', label: 'Open Hosts Page', mac: 'Disabled', pc: 'Disabled', category: 'app' },
|
|
{ id: 'open-local', action: 'openLocal', label: 'Open Local Terminal', mac: '⌘ + L', pc: 'Ctrl + L', category: 'app' },
|
|
{ id: 'open-sftp', action: 'openSftp', label: 'Open SFTP', mac: '⌘ + Shift + S', pc: 'Ctrl + Shift + S', category: 'app' },
|
|
{ id: 'port-forwarding', action: 'portForwarding', label: 'Open Port Forwarding', mac: '⌘ + P', pc: 'Ctrl + P', category: 'app' },
|
|
{ id: 'command-palette', action: 'commandPalette', label: 'Open Command Palette', mac: '⌘ + K', pc: 'Ctrl + K', category: 'app' },
|
|
{ id: 'quick-switch', action: 'quickSwitch', label: 'Quick Switch', mac: '⌘ + J', pc: 'Ctrl + J', category: 'app' },
|
|
{ id: 'snippets', action: 'snippets', label: 'Open Snippets', mac: '⌘ + Shift + S', pc: 'Ctrl + Alt + S', category: 'app' },
|
|
{ id: 'broadcast', action: 'broadcast', label: 'Switch the Broadcast Mode', mac: '⌘ + B', pc: 'Ctrl + B', category: 'app' },
|
|
];
|
|
|
|
// Terminal appearance settings
|
|
export type CursorShape = 'block' | 'bar' | 'underline';
|
|
export type RightClickBehavior = 'context-menu' | 'paste' | 'select-word';
|
|
export type LinkModifier = 'none' | 'ctrl' | 'alt' | 'meta';
|
|
export type TerminalEmulationType = 'xterm-256color' | 'xterm-16color' | 'xterm';
|
|
|
|
// Keyword highlighting configuration
|
|
export interface KeywordHighlightRule {
|
|
id: string;
|
|
label: string; // Display name (e.g., "Error", "Warning", "OK")
|
|
patterns: string[]; // Regex patterns to match
|
|
color: string; // Highlight color (hex)
|
|
enabled: boolean;
|
|
}
|
|
|
|
export interface TerminalSettings {
|
|
// Rendering
|
|
scrollback: number; // Number of lines kept in buffer
|
|
drawBoldInBrightColors: boolean; // Draw bold text in bright colors
|
|
terminalEmulationType: TerminalEmulationType; // Terminal emulation type (TERM env var)
|
|
|
|
// Font
|
|
fontLigatures: boolean; // Enable font ligatures
|
|
fontWeight: number; // Normal font weight (100-900)
|
|
fontWeightBold: number; // Bold font weight (100-900)
|
|
linePadding: number; // Additional space between lines
|
|
fallbackFont: string; // Fallback font family
|
|
|
|
// Cursor
|
|
cursorShape: CursorShape;
|
|
cursorBlink: boolean;
|
|
|
|
// Accessibility
|
|
minimumContrastRatio: number; // Minimum contrast ratio (1-21)
|
|
|
|
// Keyboard
|
|
altAsMeta: boolean; // Use ⌥ as the Meta key
|
|
scrollOnInput: boolean; // Scroll terminal to bottom on input
|
|
|
|
// Mouse
|
|
rightClickBehavior: RightClickBehavior;
|
|
copyOnSelect: boolean; // Automatically copy selected text
|
|
middleClickPaste: boolean; // Paste on middle-click
|
|
wordSeparators: string; // Characters for word selection
|
|
linkModifier: LinkModifier; // Modifier key to click links
|
|
|
|
// Keyword Highlighting
|
|
keywordHighlightEnabled: boolean;
|
|
keywordHighlightRules: KeywordHighlightRule[];
|
|
}
|
|
|
|
export const DEFAULT_KEYWORD_HIGHLIGHT_RULES: KeywordHighlightRule[] = [
|
|
{ id: 'error', label: 'Error', patterns: ['\\[error\\]', '\\[err\\]', '\\berror\\b', '\\bfail(ed)?\\b', '\\bfatal\\b', '\\bcritical\\b', '\\bexception\\b'], color: '#F87171', enabled: true },
|
|
{ id: 'warning', label: 'Warning', patterns: ['\\[warn(ing)?\\]', '\\bwarn(ing)?\\b', '\\bcaution\\b', '\\bdeprecated\\b'], color: '#FBBF24', enabled: true },
|
|
{ id: 'ok', label: 'OK', patterns: ['\\[ok\\]', '\\bok\\b', '\\bsuccess(ful)?\\b', '\\bpassed\\b', '\\bcompleted\\b', '\\bdone\\b'], color: '#34D399', enabled: true },
|
|
{ id: 'info', label: 'Info', patterns: ['\\[info\\]', '\\[notice\\]', '\\[note\\]', '\\bnotice\\b', '\\bnote\\b'], color: '#3B82F6', enabled: true },
|
|
{ id: 'debug', label: 'Debug', patterns: ['\\[debug\\]', '\\[trace\\]', '\\[verbose\\]', '\\bdebug\\b', '\\btrace\\b', '\\bverbose\\b'], color: '#A78BFA', enabled: true },
|
|
{ id: 'ip-mac', label: 'IP address & MAC', patterns: ['\\b(?:\\d{1,3}\\.){3}\\d{1,3}\\b', '\\b([0-9A-Fa-f]{2}[:-]){5}[0-9A-Fa-f]{2}\\b'], color: '#EC4899', enabled: true },
|
|
];
|
|
|
|
export const DEFAULT_TERMINAL_SETTINGS: TerminalSettings = {
|
|
scrollback: 10000,
|
|
drawBoldInBrightColors: true,
|
|
terminalEmulationType: 'xterm-256color',
|
|
fontLigatures: true,
|
|
fontWeight: 400,
|
|
fontWeightBold: 700,
|
|
linePadding: 0,
|
|
fallbackFont: '',
|
|
cursorShape: 'block',
|
|
cursorBlink: true,
|
|
minimumContrastRatio: 1,
|
|
altAsMeta: false,
|
|
scrollOnInput: true,
|
|
rightClickBehavior: 'context-menu',
|
|
copyOnSelect: false,
|
|
middleClickPaste: true,
|
|
wordSeparators: ' ()[]{}\'"',
|
|
linkModifier: 'none',
|
|
keywordHighlightEnabled: true,
|
|
keywordHighlightRules: DEFAULT_KEYWORD_HIGHLIGHT_RULES,
|
|
};
|
|
|
|
export interface TerminalTheme {
|
|
id: string;
|
|
name: string;
|
|
type: 'dark' | 'light';
|
|
colors: {
|
|
background: string;
|
|
foreground: string;
|
|
cursor: string;
|
|
selection: string;
|
|
black: string;
|
|
red: string;
|
|
green: string;
|
|
yellow: string;
|
|
blue: string;
|
|
magenta: string;
|
|
cyan: string;
|
|
white: string;
|
|
brightBlack: string;
|
|
brightRed: string;
|
|
brightGreen: string;
|
|
brightYellow: string;
|
|
brightBlue: string;
|
|
brightMagenta: string;
|
|
brightCyan: string;
|
|
brightWhite: string;
|
|
}
|
|
}
|
|
|
|
export interface TerminalSession {
|
|
id: string;
|
|
hostId: string;
|
|
hostLabel: string;
|
|
username: string;
|
|
hostname: string;
|
|
status: 'connecting' | 'connected' | 'disconnected';
|
|
workspaceId?: string;
|
|
startupCommand?: string; // Command to run after connection (for snippet runner)
|
|
// Connection-time protocol overrides (used instead of looking up from hosts)
|
|
protocol?: 'ssh' | 'telnet' | 'local';
|
|
port?: number;
|
|
moshEnabled?: boolean;
|
|
}
|
|
|
|
export interface RemoteFile {
|
|
name: string;
|
|
type: 'file' | 'directory';
|
|
size: string;
|
|
lastModified: string;
|
|
}
|
|
|
|
export type WorkspaceNode =
|
|
| {
|
|
id: string;
|
|
type: 'pane';
|
|
sessionId: string;
|
|
}
|
|
| {
|
|
id: string;
|
|
type: 'split';
|
|
direction: 'horizontal' | 'vertical';
|
|
children: WorkspaceNode[];
|
|
sizes?: number[]; // relative sizes for children
|
|
};
|
|
|
|
export type WorkspaceViewMode = 'split' | 'focus';
|
|
|
|
export interface Workspace {
|
|
id: string;
|
|
title: string;
|
|
root: WorkspaceNode;
|
|
viewMode?: WorkspaceViewMode; // 'split' = tiled view (default), 'focus' = left list + single terminal
|
|
focusedSessionId?: string; // Which session is focused when in focus mode
|
|
snippetId?: string; // If this workspace was created from running a snippet
|
|
}
|
|
|
|
// SFTP Types
|
|
export interface SftpFileEntry {
|
|
name: string;
|
|
type: 'file' | 'directory' | 'symlink';
|
|
size: number;
|
|
sizeFormatted: string;
|
|
lastModified: number;
|
|
lastModifiedFormatted: string;
|
|
permissions?: string;
|
|
owner?: string;
|
|
group?: string;
|
|
}
|
|
|
|
export interface SftpConnection {
|
|
id: string;
|
|
hostId: string;
|
|
hostLabel: string;
|
|
isLocal: boolean;
|
|
status: 'connecting' | 'connected' | 'disconnected' | 'error';
|
|
error?: string;
|
|
currentPath: string;
|
|
homeDir?: string;
|
|
}
|
|
|
|
export type TransferStatus = 'pending' | 'transferring' | 'completed' | 'failed' | 'cancelled';
|
|
export type TransferDirection = 'upload' | 'download' | 'remote-to-remote' | 'local-copy';
|
|
|
|
export interface TransferTask {
|
|
id: string;
|
|
fileName: string;
|
|
sourcePath: string;
|
|
targetPath: string;
|
|
sourceConnectionId: string;
|
|
targetConnectionId: string;
|
|
direction: TransferDirection;
|
|
status: TransferStatus;
|
|
totalBytes: number;
|
|
transferredBytes: number;
|
|
speed: number; // bytes per second
|
|
error?: string;
|
|
startTime: number;
|
|
endTime?: number;
|
|
isDirectory: boolean;
|
|
childTasks?: string[]; // For directory transfers
|
|
parentTaskId?: string;
|
|
skipConflictCheck?: boolean; // Skip conflict check for replace operations
|
|
}
|
|
|
|
export interface FileConflict {
|
|
transferId: string;
|
|
fileName: string;
|
|
sourcePath: string;
|
|
targetPath: string;
|
|
existingSize: number;
|
|
newSize: number;
|
|
existingModified: number;
|
|
newModified: number;
|
|
}
|
|
|
|
// Port Forwarding Types
|
|
export type PortForwardingType = 'local' | 'remote' | 'dynamic';
|
|
export type PortForwardingStatus = 'inactive' | 'connecting' | 'active' | 'error';
|
|
|
|
export interface PortForwardingRule {
|
|
id: string;
|
|
label: string;
|
|
type: PortForwardingType;
|
|
// Common fields
|
|
localPort: number;
|
|
bindAddress: string; // e.g., '127.0.0.1', '0.0.0.0'
|
|
// For local and remote forwarding
|
|
remoteHost?: string;
|
|
remotePort?: number;
|
|
// Host to tunnel through
|
|
hostId?: string;
|
|
// Runtime state
|
|
status: PortForwardingStatus;
|
|
error?: string;
|
|
createdAt: number;
|
|
lastUsedAt?: number;
|
|
}
|
|
|
|
// Known Hosts - discovered from system SSH known_hosts file
|
|
export interface KnownHost {
|
|
id: string;
|
|
hostname: string; // The host pattern from known_hosts
|
|
port: number;
|
|
keyType: string; // ssh-rsa, ssh-ed25519, ecdsa-sha2-nistp256, etc.
|
|
publicKey: string; // The host's public key fingerprint or full key
|
|
discoveredAt: number;
|
|
lastSeen?: number;
|
|
convertedToHostId?: string; // If converted to managed host
|
|
}
|
|
|
|
// Shell History - records real commands executed in terminal sessions
|
|
export interface ShellHistoryEntry {
|
|
id: string;
|
|
command: string;
|
|
hostId: string; // ID of the host where command was executed
|
|
hostLabel: string; // Label for display
|
|
sessionId: string;
|
|
timestamp: number;
|
|
}
|
|
|
|
// Connection Log - records connection history
|
|
export interface ConnectionLog {
|
|
id: string;
|
|
sessionId?: string; // Terminal session ID for matching during capture
|
|
hostId: string; // Host ID (can be empty for local terminal)
|
|
hostLabel: string; // Display label (e.g., 'Local Terminal' or host label)
|
|
hostname: string; // Target hostname or 'localhost'
|
|
username: string; // SSH username or system username
|
|
protocol: 'ssh' | 'telnet' | 'local' | 'mosh';
|
|
startTime: number; // Connection start timestamp
|
|
endTime?: number; // Connection end timestamp (undefined if still active)
|
|
localUsername: string; // System username of the local user
|
|
localHostname: string; // Local machine hostname
|
|
saved: boolean; // Whether this log is bookmarked/saved
|
|
terminalData?: string; // Captured terminal output data for replay
|
|
themeId?: string; // Terminal theme ID for this log view
|
|
fontSize?: number; // Terminal font size for this log view
|
|
}
|