rds_ssm_connect 1.7.4 → 1.7.6

package/.github/workflows/release.yml

@@ -28,10 +28,6 @@ jobs:
             rust_target: x86_64-unknown-linux-gnu
             sidecar_target: node22-linux-x64
             sidecar_triple: x86_64-unknown-linux-gnu
-          - platform: ubuntu-24.04-arm64
-            rust_target: aarch64-unknown-linux-gnu
-            sidecar_target: node22-linux-arm64
-            sidecar_triple: aarch64-unknown-linux-gnu
           - platform: windows-latest
             rust_target: x86_64-pc-windows-msvc
             sidecar_target: node22-win-x64

package/README.md

@@ -22,17 +22,85 @@ Secure database tunneling to AWS RDS through SSM port forwarding via bastion hos
 
 ## Installation
 
-### Desktop App
+### macOS (Homebrew)
 
-Download the latest installer for your platform from [GitHub Releases](https://github.com/yarka-guru/connection_app/releases):
+```bash
+brew tap yarka-guru/tap
+brew install --cask rds-ssm-connect
+```
 
-| Platform | Format |
-|----------|--------|
-| macOS (Apple Silicon + Intel) | `.dmg` |
-| Windows | `.msi` / `.exe` |
-| Linux | `.deb` / `.AppImage` |
+This installs the desktop app along with `aws-vault` and `awscli` dependencies. You also need the [Session Manager Plugin](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html):
 
-### CLI
+```bash
+brew install --cask session-manager-plugin
+```
+
+Or download the `.dmg` directly from [GitHub Releases](https://github.com/yarka-guru/connection_app/releases).
+
+### Linux
+
+#### Option A: Homebrew
+
+```bash
+# Install Homebrew if not already installed
+/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
+echo 'eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"' >> ~/.bashrc
+eval "$(/home/linuxbrew/.linuxbrew/bin/brew shellenv)"
+
+# Install the app (includes aws-vault and awscli as dependencies)
+brew tap yarka-guru/tap
+brew install yarka-guru/tap/rds-ssm-connect
+
+# Install Session Manager Plugin (ARM64)
+curl "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/ubuntu_arm64/session-manager-plugin.deb" -o session-manager-plugin.deb
+sudo dpkg -i session-manager-plugin.deb
+# For x86_64, replace ubuntu_arm64 with ubuntu_64bit
+
+# Make brew tools visible to the desktop app
+echo 'export PATH="/home/linuxbrew/.linuxbrew/bin:$PATH"' | sudo tee /etc/profile.d/linuxbrew.sh
+# Log out and back in for this to take effect
+```
+
+#### Option B: Direct .deb install
+
+```bash
+# 1. Download and install the app
+# ARM64:
+wget https://github.com/yarka-guru/connection_app/releases/latest/download/RDS.SSM.Connect_1.7.5_arm64.deb
+sudo dpkg -i RDS.SSM.Connect_1.7.5_arm64.deb
+# x86_64:
+# wget https://github.com/yarka-guru/connection_app/releases/latest/download/RDS.SSM.Connect_1.7.5_amd64.deb
+# sudo dpkg -i RDS.SSM.Connect_1.7.5_amd64.deb
+
+# 2. Install aws-vault
+# ARM64:
+wget https://github.com/99designs/aws-vault/releases/latest/download/aws-vault-linux-arm64 -O aws-vault
+# x86_64:
+# wget https://github.com/99designs/aws-vault/releases/latest/download/aws-vault-linux-amd64 -O aws-vault
+chmod +x aws-vault && sudo mv aws-vault /usr/local/bin/
+
+# 3. Install AWS CLI
+# ARM64:
+curl "https://awscli.amazonaws.com/awscli-exe-linux-aarch64.zip" -o awscliv2.zip
+# x86_64:
+# curl "https://awscli.amazonaws.com/awscli-exe-linux-x86_64.zip" -o awscliv2.zip
+unzip awscliv2.zip && sudo ./aws/install
+
+# 4. Install Session Manager Plugin
+# ARM64:
+curl "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/ubuntu_arm64/session-manager-plugin.deb" -o session-manager-plugin.deb
+# x86_64:
+# curl "https://s3.amazonaws.com/session-manager-downloads/plugin/latest/ubuntu_64bit/session-manager-plugin.deb" -o session-manager-plugin.deb
+sudo dpkg -i session-manager-plugin.deb
+```
+
+### Windows
+
+Download the `.msi` or `.exe` installer from [GitHub Releases](https://github.com/yarka-guru/connection_app/releases).
+
+Prerequisites must be installed separately: [aws-vault](https://github.com/99designs/aws-vault), [AWS CLI](https://aws.amazon.com/cli/), [Session Manager Plugin](https://docs.aws.amazon.com/systems-manager/latest/userguide/session-manager-working-with-install-plugin.html).
+
+### CLI (all platforms)
 
 ```bash
 npm install -g rds_ssm_connect
@@ -141,7 +209,7 @@ src/
 ## Publishing
 
 - **npm**: Published automatically via GitHub Actions when a release is created
-- **Desktop**: Multi-platform builds (macOS ARM64/x64, Linux x64, Windows x64) via `tauri-action` on git tags
+- **Desktop**: Multi-platform builds (macOS ARM64/x64, Linux ARM64/x64, Windows x64) via `tauri-action` on git tags
 
 ## License
 

package/connect.js

@@ -3,13 +3,14 @@
 import { exec } from 'node:child_process'
 import { EventEmitter } from 'node:events'
 import fs from 'node:fs/promises'
+import net from 'node:net'
 import os from 'node:os'
 import path from 'node:path'
 import { promisify } from 'node:util'
 import { PROJECT_CONFIGS } from './envPortMapping.js'
 
 // Package info for version checking
-const packageJson = { name: 'rds_ssm_connect', version: '1.6.2' }
+const packageJson = { name: 'rds_ssm_connect', version: '1.7.6' }
 
 const execAsync = promisify(exec)
 
@@ -22,6 +23,9 @@ const RETRY_CONFIG = {
   BASTION_WAIT_RETRY_DELAY_MS: 15000,
   PORT_FORWARDING_MAX_RETRIES: 2,
   SSM_AGENT_READY_WAIT_MS: 10000,
+  KEEPALIVE_INTERVAL_MS: 4 * 60 * 1000,
+  AUTO_RECONNECT_MAX_RETRIES: 50,
+  AUTO_RECONNECT_DELAY_MS: 3000,
 }
 
 // Version check configuration
@@ -119,6 +123,22 @@ async function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms))
 }
 
+// Keepalive: periodic TCP ping through the tunnel to prevent SSM idle timeout.
+// Each connection attempt generates traffic on the SSM WebSocket channel,
+// resetting the server-side idle timer (default 20 min).
+function startKeepalive(localPort) {
+  const timer = setInterval(() => {
+    const socket = new net.Socket()
+    socket.setTimeout(5000)
+    socket.connect(parseInt(localPort, 10), '127.0.0.1', () => {
+      socket.destroy()
+    })
+    socket.on('error', () => socket.destroy())
+    socket.on('timeout', () => socket.destroy())
+  }, RETRY_CONFIG.KEEPALIVE_INTERVAL_MS)
+  return () => clearInterval(timer)
+}
+
 async function terminateBastionInstance(ENV, instanceId, region) {
   const terminateCommand = `aws-vault exec ${ENV} -- aws ec2 terminate-instances --region ${region} --instance-ids ${instanceId}`
   await runCommand(terminateCommand)
@@ -487,7 +507,9 @@ async function getProfilesForProjectKey(projectKey) {
   return getProfilesForProject(allProfiles, projectConfig, PROJECT_CONFIGS)
 }
 
-// Connect to RDS through bastion - returns connection info and control object
+// Connect to RDS through bastion - returns connection info and control object.
+// Includes keepalive (prevents SSM idle timeout) and auto-reconnect
+// (transparently reconnects on the same port if session drops unexpectedly).
 async function connect(projectKey, profile, options = {}) {
   const projectConfig = PROJECT_CONFIGS[projectKey]
   if (!projectConfig) {
@@ -498,6 +520,9 @@ async function connect(projectKey, profile, options = {}) {
   // Use provided localPort or fall back to computed port from profile
   const localPort = options.localPort || getLocalPort(profile, projectConfig)
 
+  let manualDisconnect = false
+  let stopKeepalive = null
+
   // Emit status updates
   const emit = (event, data) => {
     ipcEmitter.emit(event, data)
@@ -510,12 +535,12 @@ async function connect(projectKey, profile, options = {}) {
   const credentials = await getConnectionCredentials(profile, projectConfig)
 
   emit('status', { message: 'Finding bastion instance...' })
-  const instanceId = await findBastionInstance(profile, region)
+  let currentInstanceId = await findBastionInstance(profile, region)
 
   emit('status', { message: 'Getting RDS endpoint...' })
-  const rdsEndpoint = await getRdsEndpoint(profile, projectConfig)
+  let currentRdsEndpoint = await getRdsEndpoint(profile, projectConfig)
 
-  if (!rdsEndpoint || rdsEndpoint === 'None') {
+  if (!currentRdsEndpoint || currentRdsEndpoint === 'None') {
     throw new Error('Failed to find the RDS endpoint.')
   }
 
@@ -528,29 +553,104 @@ async function connect(projectKey, profile, options = {}) {
     username: credentials.username,
     password: credentials.password,
     database,
-    rdsEndpoint,
-    instanceId,
+    rdsEndpoint: currentRdsEndpoint,
+    instanceId: currentInstanceId,
   }
 
   emit('credentials', connectionInfo)
   emit('status', { message: 'Starting port forwarding...' })
 
-  // Start port forwarding
-  const portForwardingPromise = startPortForwardingWithConfig(
-    profile,
-    instanceId,
-    rdsEndpoint,
-    localPort,
-    rdsPort,
-    region,
-    0,
-    RETRY_CONFIG.PORT_FORWARDING_MAX_RETRIES,
-  )
+  // Auto-reconnect session management loop.
+  // Keeps the tunnel alive on the SAME local port. Only exits on
+  // manual disconnect or after exhausting reconnection attempts.
+  const portForwardingPromise = (async () => {
+    let reconnectCount = 0
+
+    while (!manualDisconnect) {
+      try {
+        stopKeepalive = startKeepalive(localPort)
+
+        await startPortForwardingWithConfig(
+          profile,
+          currentInstanceId,
+          currentRdsEndpoint,
+          localPort,
+          rdsPort,
+          region,
+          0,
+          RETRY_CONFIG.PORT_FORWARDING_MAX_RETRIES,
+        )
+
+        // Session ended — clean up keepalive
+        stopKeepalive?.()
+        stopKeepalive = null
+
+        if (manualDisconnect) break
+
+        // Unexpected disconnect (idle timeout, network issue) — auto-reconnect
+        reconnectCount++
+        if (reconnectCount > RETRY_CONFIG.AUTO_RECONNECT_MAX_RETRIES) {
+          throw new Error('Maximum auto-reconnection attempts reached.')
+        }
+
+        emit('status', {
+          message: `Session ended. Reconnecting... (${reconnectCount})`,
+        })
+        await sleep(RETRY_CONFIG.AUTO_RECONNECT_DELAY_MS)
+
+        if (manualDisconnect) break
+
+        // Re-discover infrastructure (bastion may have been replaced by ASG)
+        emit('status', { message: 'Finding bastion instance...' })
+        currentInstanceId = await findBastionInstance(profile, region)
+
+        emit('status', { message: 'Getting RDS endpoint...' })
+        currentRdsEndpoint = await getRdsEndpoint(profile, projectConfig)
+
+        if (!currentRdsEndpoint || currentRdsEndpoint === 'None') {
+          throw new Error(
+            'Failed to find the RDS endpoint during reconnection.',
+          )
+        }
+
+        emit('status', { message: 'Reconnecting port forwarding...' })
+      } catch (error) {
+        stopKeepalive?.()
+        stopKeepalive = null
+
+        if (manualDisconnect) break
+
+        reconnectCount++
+        if (reconnectCount > RETRY_CONFIG.AUTO_RECONNECT_MAX_RETRIES) {
+          throw error
+        }
+
+        emit('status', {
+          message: `Connection error. Retrying... (${reconnectCount}/${RETRY_CONFIG.AUTO_RECONNECT_MAX_RETRIES})`,
+        })
+        await sleep(RETRY_CONFIG.AUTO_RECONNECT_DELAY_MS * 2)
+
+        if (manualDisconnect) break
+
+        try {
+          currentInstanceId = await findBastionInstance(profile, region)
+          currentRdsEndpoint = await getRdsEndpoint(profile, projectConfig)
+          if (!currentRdsEndpoint || currentRdsEndpoint === 'None') {
+            throw new Error('Failed to find RDS endpoint')
+          }
+        } catch (_innerError) {
+          // Will retry on next loop iteration
+        }
+      }
+    }
+  })()
 
   // Return connection control object
   return {
     connectionInfo,
     disconnect: () => {
+      manualDisconnect = true
+      stopKeepalive?.()
       // Kill all active child processes
       activeChildProcesses.forEach((child) => {
         if (child && !child.killed) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rds_ssm_connect",
-  "version": "1.7.4",
+  "version": "1.7.6",
   "type": "module",
   "repository": {
     "type": "git",

package/src/App.svelte

@@ -206,7 +206,7 @@ async function openUrl(url) {
 async function loadProfiles() {
   if (!selectedProject) return
   try {
-    profiles = await invoke('listprofiles', { projectKey: selectedProject })
+    profiles = await invoke('list_profiles', { projectKey: selectedProject })
     selectedProfile = ''
   } catch (err) {
     errorMessage = `Failed to load profiles: ${err}`

package/src-tauri/Cargo.lock

@@ -3057,7 +3057,7 @@ checksum = "20675572f6f24e9e76ef639bc5552774ed45f1c30e2951e1e99c59888861c539"
 
 [[package]]
 name = "rds-ssm-connect"
-version = "1.7.4"
+version = "1.7.5"
 dependencies = [
  "reqwest 0.12.28",
  "semver",

package/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "rds-ssm-connect"
-version = "1.7.4"
+version = "1.7.6"
 description = "Secure RDS connections through AWS SSM"
 authors = ["Iaroslav Pyrogov"]
 edition = "2024"

package/src-tauri/src/lib.rs

@@ -133,7 +133,7 @@ async fn ensure_sidecar(
     // Get current PATH and extend with common installation locations
     let current_path = std::env::var("PATH").unwrap_or_default();
     let extended_path = format!(
-        "{}:/usr/local/bin:/opt/homebrew/bin:{}/.local/bin",
+        "{}:/usr/local/bin:/opt/homebrew/bin:/home/linuxbrew/.linuxbrew/bin:{}/.local/bin",
         current_path,
         std::env::var("HOME").unwrap_or_default()
     );

package/src-tauri/tauri.conf.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://schema.tauri.app/config/2",
   "productName": "RDS SSM Connect",
-  "version": "1.7.4",
+  "version": "1.7.6",
   "identifier": "com.rds-ssm-connect.desktop",
   "build": {
     "beforeDevCommand": "npm run dev:vite",