rds_ssm_connect 1.7.12 → 1.7.14

package/.github/workflows/release.yml

@@ -28,6 +28,10 @@ jobs:
             rust_target: x86_64-unknown-linux-gnu
             sidecar_target: node22-linux-x64
             sidecar_triple: x86_64-unknown-linux-gnu
+          - platform: ubuntu-22.04-arm
+            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
@@ -57,7 +61,7 @@ jobs:
         if: startsWith(matrix.platform, 'ubuntu')
         run: |
           sudo apt-get update
-          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf
+          sudo apt-get install -y libwebkit2gtk-4.1-dev libappindicator3-dev librsvg2-dev patchelf xdg-utils
 
       - name: Install dependencies (macOS)
         if: startsWith(matrix.platform, 'macos')

package/configLoader.js

@@ -0,0 +1,86 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+
+const CONFIG_DIR = path.join(os.homedir(), '.rds-ssm-connect')
+const CONFIG_FILE = 'projects.json'
+
+export function getConfigPath() {
+  return path.join(CONFIG_DIR, CONFIG_FILE)
+}
+
+export async function loadProjectConfigs(configPath) {
+  const filePath = configPath || getConfigPath()
+  try {
+    const data = await fs.readFile(filePath, 'utf-8')
+    return JSON.parse(data)
+  } catch (err) {
+    if (err.code === 'ENOENT') return {}
+    throw err
+  }
+}
+
+export async function saveProjectConfigs(configs, configPath) {
+  const filePath = configPath || getConfigPath()
+  await fs.mkdir(path.dirname(filePath), { recursive: true })
+  await fs.writeFile(filePath, JSON.stringify(configs, null, 2) + '\n')
+}
+
+export async function saveProjectConfig(key, config, configPath) {
+  const configs = await loadProjectConfigs(configPath)
+  configs[key] = config
+  await saveProjectConfigs(configs, configPath)
+}
+
+export async function deleteProjectConfig(key, configPath) {
+  const configs = await loadProjectConfigs(configPath)
+  delete configs[key]
+  await saveProjectConfigs(configs, configPath)
+}
+
+const REQUIRED_FIELDS = [
+  'name',
+  'region',
+  'database',
+  'secretPrefix',
+  'rdsType',
+  'rdsPattern',
+  'envPortMapping',
+  'defaultPort',
+]
+
+const VALID_RDS_TYPES = ['cluster', 'instance']
+const REGION_PATTERN = /^[a-z]{2}(-[a-z]+-\d+)$/
+const PORT_PATTERN = /^\d+$/
+
+export function validateProjectConfig(config) {
+  const errors = []
+
+  for (const field of REQUIRED_FIELDS) {
+    if (config[field] === undefined || config[field] === null || config[field] === '') {
+      errors.push(`Missing required field: ${field}`)
+    }
+  }
+
+  if (config.rdsType && !VALID_RDS_TYPES.includes(config.rdsType)) {
+    errors.push(`rdsType must be one of: ${VALID_RDS_TYPES.join(', ')}`)
+  }
+
+  if (config.region && !REGION_PATTERN.test(config.region)) {
+    errors.push(`Invalid region format: ${config.region}`)
+  }
+
+  if (config.defaultPort && !PORT_PATTERN.test(config.defaultPort)) {
+    errors.push(`defaultPort must be a numeric string: ${config.defaultPort}`)
+  }
+
+  if (config.envPortMapping && typeof config.envPortMapping === 'object') {
+    for (const [key, value] of Object.entries(config.envPortMapping)) {
+      if (!PORT_PATTERN.test(value)) {
+        errors.push(`Port for "${key}" must be a numeric string: ${value}`)
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors }
+}

package/connect.js

@@ -7,10 +7,14 @@ 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'
+import {
+  loadProjectConfigs,
+  saveProjectConfig,
+  validateProjectConfig,
+} from './configLoader.js'
 
 // Package info for version checking
-const packageJson = { name: 'rds_ssm_connect', version: '1.7.12' }
+const packageJson = { name: 'rds_ssm_connect', version: '1.7.14' }
 
 const execAsync = promisify(exec)
 
@@ -389,21 +393,34 @@ async function getRdsPort(ENV, projectConfig) {
 }
 
 function getProfilesForProject(allProfiles, projectConfig, allProjectConfigs) {
-  const { profileFilter } = projectConfig
+  const { profileFilter, envPortMapping } = projectConfig
 
+  let filtered
   if (profileFilter) {
     // Project has explicit filter - return profiles starting with filter
-    return allProfiles.filter((env) => env.startsWith(profileFilter))
+    filtered = allProfiles.filter((env) => env.startsWith(profileFilter))
   } else {
     // No filter (legacy project like TLN) - return profiles that don't match any other project's filter
     const otherFilters = Object.values(allProjectConfigs)
       .filter((config) => config.profileFilter)
       .map((config) => config.profileFilter)
 
-    return allProfiles.filter(
+    filtered = allProfiles.filter(
       (env) => !otherFilters.some((filter) => env.startsWith(filter)),
     )
   }
+
+  // Further restrict to profiles matching an envPortMapping suffix
+  if (envPortMapping && Object.keys(envPortMapping).length > 0) {
+    const suffixes = Object.keys(envPortMapping).sort(
+      (a, b) => b.length - a.length,
+    )
+    filtered = filtered.filter((env) =>
+      suffixes.some((suffix) => env.endsWith(suffix) || env === suffix),
+    )
+  }
+
+  return filtered
 }
 
 // Get local port number based on environment suffix
@@ -480,6 +497,8 @@ async function getAvailableProjects() {
     return []
   }
 
+  const PROJECT_CONFIGS = await loadProjectConfigs()
+
   return Object.entries(PROJECT_CONFIGS)
     .filter(([_key, config]) => {
       const matchingProfiles = getProfilesForProject(
@@ -498,6 +517,7 @@ async function getAvailableProjects() {
 // Get profiles for a specific project
 async function getProfilesForProjectKey(projectKey) {
   const allProfiles = await readAwsConfig()
+  const PROJECT_CONFIGS = await loadProjectConfigs()
   const projectConfig = PROJECT_CONFIGS[projectKey]
 
   if (!projectConfig) {
@@ -511,6 +531,7 @@ async function getProfilesForProjectKey(projectKey) {
 // 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 PROJECT_CONFIGS = await loadProjectConfigs()
   const projectConfig = PROJECT_CONFIGS[projectKey]
   if (!projectConfig) {
     throw new Error(`Unknown project: ${projectKey}`)
@@ -674,6 +695,116 @@ async function main() {
   await checkForUpdates()
 
   try {
+    // Load project configs from user config file
+    let PROJECT_CONFIGS = await loadProjectConfigs()
+
+    // First-run wizard: if no projects configured, prompt to create one
+    if (Object.keys(PROJECT_CONFIGS).length === 0) {
+      const { setupNow } = await inquirer.default.prompt([
+        {
+          type: 'confirm',
+          name: 'setupNow',
+          message:
+            'No projects configured. Would you like to set up a project now?',
+          default: true,
+        },
+      ])
+
+      if (!setupNow) {
+        console.log(
+          `\nTo configure manually, create ~/.rds-ssm-connect/projects.json\nSee the README for the config schema.\n`,
+        )
+        return
+      }
+
+      const answers = await inquirer.default.prompt([
+        {
+          type: 'input',
+          name: 'key',
+          message: 'Project key (lowercase, hyphens):',
+          validate: (v) =>
+            /^[a-z][a-z0-9-]*$/.test(v) || 'Lowercase letters, digits, hyphens',
+        },
+        { type: 'input', name: 'name', message: 'Display name:' },
+        {
+          type: 'input',
+          name: 'region',
+          message: 'AWS region:',
+          default: 'us-east-1',
+        },
+        { type: 'input', name: 'database', message: 'Database name:' },
+        {
+          type: 'input',
+          name: 'secretPrefix',
+          message: 'Secret prefix (e.g. rds!cluster):',
+        },
+        {
+          type: 'select',
+          name: 'rdsType',
+          message: 'RDS type:',
+          choices: ['cluster', 'instance'],
+        },
+        {
+          type: 'input',
+          name: 'rdsPattern',
+          message: 'RDS identifier pattern:',
+        },
+        {
+          type: 'input',
+          name: 'profileFilter',
+          message: 'Profile filter prefix (leave empty for none):',
+          default: '',
+        },
+        {
+          type: 'input',
+          name: 'defaultPort',
+          message: 'Default local port:',
+          default: '5432',
+        },
+      ])
+
+      // Collect port mappings
+      const envPortMappingInput = {}
+      let addMore = true
+      while (addMore) {
+        const mapping = await inquirer.default.prompt([
+          { type: 'input', name: 'suffix', message: 'Environment suffix:' },
+          { type: 'input', name: 'port', message: 'Local port:' },
+          {
+            type: 'confirm',
+            name: 'more',
+            message: 'Add another port mapping?',
+            default: false,
+          },
+        ])
+        envPortMappingInput[mapping.suffix] = mapping.port
+        addMore = mapping.more
+      }
+
+      const newConfig = {
+        name: answers.name,
+        region: answers.region,
+        database: answers.database,
+        secretPrefix: answers.secretPrefix,
+        rdsType: answers.rdsType,
+        rdsPattern: answers.rdsPattern,
+        profileFilter: answers.profileFilter || null,
+        envPortMapping: envPortMappingInput,
+        defaultPort: answers.defaultPort,
+      }
+
+      const validation = validateProjectConfig(newConfig)
+      if (!validation.valid) {
+        console.log('\nValidation errors:')
+        validation.errors.forEach((e) => console.log(`  - ${e}`))
+        return
+      }
+
+      await saveProjectConfig(answers.key, newConfig)
+      console.log(`\nProject "${answers.name}" saved!\n`)
+      PROJECT_CONFIGS = await loadProjectConfigs()
+    }
+
     // Read all AWS profiles first
     const allProfiles = await readAwsConfig()
 
@@ -834,6 +965,6 @@ export {
   getLocalPort,
   connect,
   ipcEmitter,
-  PROJECT_CONFIGS,
+  loadProjectConfigs,
   RETRY_CONFIG,
 }

package/gui-adapter.js

@@ -22,8 +22,13 @@ import {
   getAvailableProjects,
   getLocalPort,
   getProfilesForProjectKey,
-  PROJECT_CONFIGS,
+  loadProjectConfigs,
 } from './connect.js'
+import {
+  deleteProjectConfig,
+  saveProjectConfig,
+  validateProjectConfig,
+} from './configLoader.js'
 
 // Active connections Map - connectionId -> connection control object
 const activeConnections = new Map()
@@ -51,19 +56,6 @@ async function isPortAvailable(port) {
   })
 }
 
-// Find next available port starting from basePort
-async function findAvailablePort(basePort, usedPorts = []) {
-  const usedSet = new Set(usedPorts.map((p) => parseInt(p, 10)))
-
-  for (let port = basePort; port < basePort + 100; port++) {
-    if (usedSet.has(port)) continue
-    if (await isPortAvailable(port)) {
-      return port.toString()
-    }
-  }
-  throw new Error(`No available ports found starting from ${basePort}`)
-}
-
 // Handle incoming commands
 async function handleCommand(command) {
   const { id, action, ...params } = command
@@ -100,7 +92,8 @@ async function handleCommand(command) {
         const connectionId = `conn_${randomUUID().slice(0, 8)}`
 
         // Determine port to use
-        const projectConfig = PROJECT_CONFIGS[projectKey]
+        const configs = await loadProjectConfigs()
+        const projectConfig = configs[projectKey]
         if (!projectConfig) {
           sendResponse(id, 'error', {
             message: `Unknown project: ${projectKey}`,
@@ -108,31 +101,21 @@ async function handleCommand(command) {
           break
         }
 
-        let portToUse
-        if (localPort) {
-          // Use specified port if available
-          const portNum = parseInt(localPort, 10)
-          if (
-            usedPorts.includes(localPort) ||
-            !(await isPortAvailable(portNum))
-          ) {
-            sendResponse(id, 'error', {
-              message: `Port ${localPort} is not available`,
-            })
-            break
-          }
-          portToUse = localPort
-        } else {
-          // Find next available port based on project's base port
-          const basePort = parseInt(getLocalPort(profile, projectConfig), 10)
-          // Combine usedPorts from params with currently active connections
-          const allUsedPorts = [
-            ...usedPorts,
-            ...Array.from(activeConnections.values()).map(
-              (c) => c.connectionInfo?.port,
-            ),
-          ].filter(Boolean)
-          portToUse = await findAvailablePort(basePort, allUsedPorts)
+        const portToUse = localPort || getLocalPort(profile, projectConfig)
+        const portNum = parseInt(portToUse, 10)
+
+        // Strict port check — never silently increment
+        const allUsedPorts = new Set([
+          ...usedPorts.map((p) => parseInt(p, 10)),
+          ...Array.from(activeConnections.values())
+            .map((c) => parseInt(c.connectionInfo?.port, 10))
+            .filter(Boolean),
+        ])
+        if (allUsedPorts.has(portNum) || !(await isPortAvailable(portNum))) {
+          sendResponse(id, 'error', {
+            message: `Port ${portToUse} is not available. Close the application using it or change the port in project settings.`,
+          })
+          break
         }
 
         // Start new connection with the determined port
@@ -220,6 +203,43 @@ async function handleCommand(command) {
         break
       }
 
+      case 'list-project-configs': {
+        const configs = await loadProjectConfigs()
+        sendResponse(id, 'success', { configs })
+        break
+      }
+
+      case 'save-project-config': {
+        const { key, config } = params
+        if (!key || !config) {
+          sendResponse(id, 'error', {
+            message: 'key and config are required',
+          })
+          break
+        }
+        const validation = validateProjectConfig(config)
+        if (!validation.valid) {
+          sendResponse(id, 'error', {
+            message: `Validation failed: ${validation.errors.join(', ')}`,
+          })
+          break
+        }
+        await saveProjectConfig(key, config)
+        sendResponse(id, 'success', { message: 'Project config saved' })
+        break
+      }
+
+      case 'delete-project-config': {
+        const { key: deleteKey } = params
+        if (!deleteKey) {
+          sendResponse(id, 'error', { message: 'key is required' })
+          break
+        }
+        await deleteProjectConfig(deleteKey)
+        sendResponse(id, 'success', { message: 'Project config deleted' })
+        break
+      }
+
       case 'ping': {
         sendResponse(id, 'success', { message: 'pong' })
         break

package/package.json

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

package/scripts/generate-update-json.js

@@ -39,6 +39,7 @@ const TARGET_TO_PLATFORM = {
   'aarch64-apple-darwin': 'darwin-aarch64',
   'x86_64-apple-darwin': 'darwin-x86_64',
   'x86_64-unknown-linux-gnu': 'linux-x86_64',
+  'aarch64-unknown-linux-gnu': 'linux-aarch64',
   'x86_64-pc-windows-msvc': 'windows-x86_64',
 }
 
@@ -97,3 +98,13 @@ const updateManifest = {
 
 const outputPath = path.join(__dirname, '../latest.json')
 fs.writeFileSync(outputPath, JSON.stringify(updateManifest, null, 2))
+
+// Warn if latest.json is not gitignored (it should never be committed)
+const gitignorePath = path.join(__dirname, '../.gitignore')
+try {
+  const gitignore = fs.readFileSync(gitignorePath, 'utf-8')
+  if (!gitignore.includes('latest.json')) {
+    console.warn('WARNING: latest.json is not in .gitignore — add it to avoid accidental commits')
+  }
+} catch {}
+

package/src/App.svelte

@@ -32,6 +32,7 @@ let showSavePrompt = $state(false)
 let lastConnectedConfig = $state(null)
 let saveConnectionName = $state('')
 let showDeleteConfirm = $state(null)
+let showCloseConfirm = $state(false)
 let isCheckingUpdates = $state(false)
 let updateCheckMessage = $state('')
 
@@ -42,10 +43,12 @@ let showSettings = $state(false)
 
 let invoke = null
 let listen = null
+let appWindow = null
 
 // Cleanup references
 let cancelUpdateMsgTimeout = null
 let unlistenSidecar = null
+let unlistenCloseRequested = null
 
 // Global keyboard shortcuts
 function handleGlobalKeydown(e) {
@@ -83,21 +86,31 @@ async function initApp() {
   loadingProjects = true
 
   try {
-    const [core, event] = await withTimeout(
+    const [core, event, windowModule] = await withTimeout(
       Promise.all([
         import('@tauri-apps/api/core'),
         import('@tauri-apps/api/event'),
+        import('@tauri-apps/api/window'),
       ]),
       5000,
     )
     invoke = core.invoke
     listen = event.listen
+    appWindow = windowModule.getCurrentWindow()
   } catch (err) {
     errorMessage = `Failed to load Tauri API: ${err}`
     loadingProjects = false
     return
   }
 
+  // Intercept window close — prompt if there are active connections
+  unlistenCloseRequested = await appWindow.onCloseRequested(async (event) => {
+    if (activeConnections.length > 0) {
+      event.preventDefault()
+      showCloseConfirm = true
+    }
+  })
+
   // Set up sidecar listener (non-blocking)
   listen('sidecar-event', (ev) => {
     const data = ev.payload
@@ -159,8 +172,23 @@ function retryInit() {
 onDestroy(() => {
   cancelUpdateMsgTimeout?.()
   unlistenSidecar?.()
+  unlistenCloseRequested?.()
 })
 
+async function confirmClose() {
+  showCloseConfirm = false
+  try {
+    await invoke('disconnect_all')
+  } catch (_err) {
+    // Best-effort disconnect before closing
+  }
+  await invoke('quit_app')
+}
+
+function cancelClose() {
+  showCloseConfirm = false
+}
+
 async function checkForUpdates() {
   if (isCheckingUpdates) return
   isCheckingUpdates = true
@@ -213,6 +241,14 @@ async function loadProfiles() {
   }
 }
 
+async function refreshProjects() {
+  try {
+    projects = await invoke('list_projects')
+  } catch (err) {
+    errorMessage = `Failed to refresh projects: ${err}`
+  }
+}
+
 async function handleConnect() {
   if (!selectedProject || !selectedProfile) return
 
@@ -490,6 +526,7 @@ const isAlreadySaved = $derived(
             {savedConnections}
             {activeConnections}
             {projects}
+            {connectingId}
             onConnect={handleSavedConnectionConnect}
             onDisconnect={handleDisconnectOne}
             onDelete={handleDeleteSavedConnection}
@@ -586,6 +623,18 @@ const isAlreadySaved = $derived(
       />
     {/if}
 
+    {#if showCloseConfirm}
+      <ConfirmDialog
+        title="Close Application"
+        message="All active connections will be closed. Are you sure you want to quit?"
+        confirmLabel="Quit"
+        cancelLabel="Cancel"
+        destructive={true}
+        onConfirm={confirmClose}
+        onCancel={cancelClose}
+      />
+    {/if}
+
     {#if showPrerequisites}
       <PrerequisitesCheck
         prerequisites={prerequisitesData}
@@ -598,6 +647,7 @@ const isAlreadySaved = $derived(
       <Settings
         onClose={() => showSettings = false}
         {invoke}
+        onProjectsChanged={refreshProjects}
       />
     {/if}
   {/if}