rds_ssm_connect 1.5.2 → 1.6.2

package/.github/workflows/npm-publish.yml

@@ -3,16 +3,19 @@ on:
   release:
     types: [published]
   workflow_dispatch:
+
 jobs:
   build:
     runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      id-token: write
     steps:
-      - uses: actions/checkout@v3
-      - uses: actions/setup-node@v3
+      - uses: actions/checkout@v6
+      - uses: actions/setup-node@v6
         with:
-          node-version: '20.x'
+          node-version: '22.x'
           registry-url: 'https://registry.npmjs.org'
+      - run: npm install -g npm@latest
       - run: npm ci
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - run: npm publish --access public

package/CLAUDE.md

@@ -16,20 +16,22 @@ This file provides guidance to Claude Code (claude.ai/code) when working with co
   - Establishes SSM port forwarding session
 
 ### Configuration
-- `envPortMapping.js` - Environment-to-port mapping configuration
-  - Maps environment suffixes (dev, stage, prod, team1-5, qa1-5, etc.) to local port numbers (5433-5452)
-  - Defines default database name: `emr`
-  - Defines AWS region: `us-east-2`
-  - **Critical**: When adding new environments, update this mapping to assign unique ports
+- `envPortMapping.js` - Multi-project configuration
+  - `PROJECT_CONFIGS` - Object containing per-project settings:
+    - `tln`: TLN/EMR project (us-east-2, Aurora clusters, `rds!cluster` secrets)
+    - `covered`: Covered Healthcare project (us-west-1, RDS instances, `rds!db` secrets)
+  - Each project defines: region, database, secretPrefix, rdsType, rdsPattern, profileFilter, envPortMapping
+  - Legacy exports maintained for backward compatibility
 
 ### Core Flow
 1. Read AWS profiles from `~/.aws/config`
-2. Prompt user to select environment (AWS profile)
-3. Query Secrets Manager for RDS credentials (secrets starting with `rds!cluster`)
-4. Find running bastion instance (tagged with `Name=*bastion*`)
-5. Get RDS Aurora cluster endpoint (cluster IDs ending with `-rds-aurora`)
-6. Start SSM port forwarding session
-7. Display connection details for database client
+2. Prompt user to select project (TLN or Covered)
+3. Filter and prompt for environment (AWS profile) based on project
+4. Query Secrets Manager for RDS credentials (project-specific prefix)
+5. Find running bastion instance (tagged with `Name=*bastion*`)
+6. Get RDS endpoint (cluster or instance based on project config)
+7. Start SSM port forwarding session with correct remote port
+8. Display connection details for database client
 
 ## Development Commands
 
@@ -71,17 +73,27 @@ Package is published to npm via GitHub Actions workflow (`.github/workflows/npm-
 
 ## AWS Resource Naming Conventions
 
-The application relies on specific AWS resource naming patterns:
+The application relies on specific AWS resource naming patterns (per project):
+
+**TLN Project:**
 - **Secrets**: Must start with `rds!cluster`
 - **Bastion instances**: Must be tagged with `Name=*bastion*` and in `running` state
 - **RDS clusters**: DBClusterIdentifier must end with `-rds-aurora` and be in `available` state
+- **Region**: us-east-2
+
+**Covered Project:**
+- **Secrets**: Must start with `rds!db`
+- **Bastion instances**: Must be tagged with `Name=*bastion*` and in `running` state
+- **RDS instances**: DBInstanceIdentifier must contain `covered-db` and be in `available` state
+- **Region**: us-west-1
+- **AWS Profiles**: Must start with `covered` (e.g., `covered`, `covered-staging`)
 
 ## Important Notes
 
-- Port assignment is based on longest-matching environment suffix (e.g., `my-team-dev` matches `dev` → port 5433)
+- Port assignment is based on project-specific port mappings
 - The tool keeps the SSM session running until Ctrl+C is pressed
-- Default port is 5432 if no environment suffix matches
-- All AWS operations use the `us-east-2` region by default
+- Each project has its own default port if no environment suffix matches
+- AWS region is determined by the selected project
 
 ## Error Handling & Recovery
 

package/connect.js

@@ -6,7 +6,11 @@ import os from 'os'
 import path from 'path'
 import { exec } from 'child_process'
 import { promisify } from 'util'
-import { envPortMapping, REGION, TABLE_NAME } from './envPortMapping.js'
+import { createRequire } from 'module'
+import { PROJECT_CONFIGS } from './envPortMapping.js'
+
+const require = createRequire(import.meta.url)
+const packageJson = require('./package.json')
 
 const execAsync = promisify(exec)
 
@@ -18,6 +22,44 @@ const RETRY_CONFIG = {
   SSM_AGENT_READY_WAIT_MS: 10000
 }
 
+// Version check configuration
+const VERSION_CHECK_TIMEOUT_MS = 3000
+const PACKAGE_NAME = packageJson.name
+const CURRENT_VERSION = packageJson.version
+
+async function checkForUpdates () {
+  try {
+    const controller = new AbortController()
+    const timeoutId = setTimeout(() => controller.abort(), VERSION_CHECK_TIMEOUT_MS)
+
+    const response = await fetch(`https://registry.npmjs.org/${PACKAGE_NAME}/latest`, {
+      signal: controller.signal
+    })
+    clearTimeout(timeoutId)
+
+    if (!response.ok) return
+
+    const data = await response.json()
+    const latestVersion = data.version
+
+    if (latestVersion && latestVersion !== CURRENT_VERSION) {
+      const [latestMajor, latestMinor, latestPatch] = latestVersion.split('.').map(Number)
+      const [currentMajor, currentMinor, currentPatch] = CURRENT_VERSION.split('.').map(Number)
+
+      const isNewer = latestMajor > currentMajor ||
+        (latestMajor === currentMajor && latestMinor > currentMinor) ||
+        (latestMajor === currentMajor && latestMinor === currentMinor && latestPatch > currentPatch)
+
+      if (isNewer) {
+        console.log(`\n  Update available: ${CURRENT_VERSION} → ${latestVersion}`)
+        console.log(`  Run: npm update -g ${PACKAGE_NAME}\n`)
+      }
+    }
+  } catch {
+    // Silently ignore version check failures
+  }
+}
+
 // Store active child processes for cleanup
 let activeChildProcesses = []
 
@@ -44,6 +86,7 @@ async function readAwsConfig () {
     const awsConfig = await fs.readFile(awsConfigPath, { encoding: 'utf-8' })
     return awsConfig
       .split(/\r?\n/)
+      .map(line => line.trim())
       .filter(line => line.startsWith('[') && line.endsWith(']'))
       .map(line => line.slice(1, -1))
       .map(line => line.replace('profile ', '').trim())
@@ -68,27 +111,27 @@ async function sleep (ms) {
   return new Promise(resolve => setTimeout(resolve, ms))
 }
 
-async function terminateBastionInstance (ENV, instanceId) {
+async function terminateBastionInstance (ENV, instanceId, region) {
   console.log(`Terminating disconnected bastion instance: ${instanceId}`)
-  const terminateCommand = `aws-vault exec ${ENV} -- aws ec2 terminate-instances --region ${REGION} --instance-ids ${instanceId}`
+  const terminateCommand = `aws-vault exec ${ENV} -- aws ec2 terminate-instances --region ${region} --instance-ids ${instanceId}`
   await runCommand(terminateCommand)
   console.log('Bastion instance terminated. ASG will spin up a new instance...')
 }
 
-async function waitForNewBastionInstance (ENV, oldInstanceId, maxRetries = RETRY_CONFIG.BASTION_WAIT_MAX_RETRIES, retryDelay = RETRY_CONFIG.BASTION_WAIT_RETRY_DELAY_MS) {
+async function waitForNewBastionInstance (ENV, oldInstanceId, region, maxRetries = RETRY_CONFIG.BASTION_WAIT_MAX_RETRIES, retryDelay = RETRY_CONFIG.BASTION_WAIT_RETRY_DELAY_MS) {
   console.log('Waiting for new bastion instance to be ready...')
 
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
     console.log(`Checking for new bastion instance (attempt ${attempt}/${maxRetries})...`)
 
-    const instanceIdCommand = `aws-vault exec ${ENV} -- aws ec2 describe-instances --region ${REGION} --filters "Name=tag:Name,Values='*bastion*'" "Name=instance-state-name,Values=running" --query "Reservations[].Instances[].[InstanceId] | [0][0]" --output text`
+    const instanceIdCommand = `aws-vault exec ${ENV} -- aws ec2 describe-instances --region ${region} --filters "Name=tag:Name,Values='*bastion*'" "Name=instance-state-name,Values=running" --query "Reservations[].Instances[].[InstanceId] | [0][0]" --output text`
     const newInstanceId = await runCommand(instanceIdCommand)
 
     if (newInstanceId && newInstanceId !== oldInstanceId && newInstanceId !== 'None') {
       console.log(`New bastion instance found: ${newInstanceId}`)
 
       // Verify SSM agent is ready
-      const isReady = await waitForSSMAgentReady(ENV, newInstanceId)
+      const isReady = await waitForSSMAgentReady(ENV, newInstanceId, region)
       if (isReady) {
         return newInstanceId
       } else {
@@ -104,11 +147,11 @@ async function waitForNewBastionInstance (ENV, oldInstanceId, maxRetries = RETRY
   return null
 }
 
-async function waitForSSMAgentReady (ENV, instanceId, maxRetries = 10, retryDelay = 3000) {
+async function waitForSSMAgentReady (ENV, instanceId, region, maxRetries = 10, retryDelay = 3000) {
   console.log('Verifying SSM agent status...')
 
   for (let attempt = 1; attempt <= maxRetries; attempt++) {
-    const ssmStatusCommand = `aws-vault exec ${ENV} -- aws ssm describe-instance-information --region ${REGION} --filters "Key=InstanceIds,Values=${instanceId}" --query "InstanceInformationList[0].PingStatus" --output text`
+    const ssmStatusCommand = `aws-vault exec ${ENV} -- aws ssm describe-instance-information --region ${region} --filters "Key=InstanceIds,Values=${instanceId}" --query "InstanceInformationList[0].PingStatus" --output text`
     const status = await runCommand(ssmStatusCommand)
 
     if (status === 'Online') {
@@ -166,14 +209,14 @@ function monitorPortForwardingSession (child) {
   return state
 }
 
-async function handleTargetNotConnectedError (ENV, instanceId, rdsEndpoint, portNumber, retryCount, maxRetries) {
+async function handleTargetNotConnectedError (ENV, instanceId, rdsEndpoint, portNumber, remotePort, region, retryCount, maxRetries) {
   console.log(`\nDetected TargetNotConnected error. Attempting recovery (retry ${retryCount + 1}/${maxRetries})...`)
 
   // Terminate the disconnected instance
-  await terminateBastionInstance(ENV, instanceId)
+  await terminateBastionInstance(ENV, instanceId, region)
 
   // Wait for new instance to be ready
-  const newInstanceId = await waitForNewBastionInstance(ENV, instanceId)
+  const newInstanceId = await waitForNewBastionInstance(ENV, instanceId, region)
 
   if (!newInstanceId) {
     throw new Error('Failed to find new bastion instance after waiting.')
@@ -181,11 +224,11 @@ async function handleTargetNotConnectedError (ENV, instanceId, rdsEndpoint, port
 
   // Retry with new instance
   console.log('Retrying port forwarding with new bastion instance...')
-  return await startPortForwarding(ENV, newInstanceId, rdsEndpoint, portNumber, retryCount + 1, maxRetries)
+  return await startPortForwardingWithConfig(ENV, newInstanceId, rdsEndpoint, portNumber, remotePort, region, retryCount + 1, maxRetries)
 }
 
-function executePortForwardingCommand (ENV, instanceId, rdsEndpoint, portNumber) {
-  const portForwardingCommand = `aws-vault exec ${ENV} -- aws ssm start-session --target ${instanceId} --document-name AWS-StartPortForwardingSessionToRemoteHost --parameters "host=${rdsEndpoint},portNumber='5432',localPortNumber='${portNumber}'" --cli-connect-timeout 0`
+function executePortForwardingCommand (ENV, instanceId, rdsEndpoint, portNumber, remotePort, region) {
+  const portForwardingCommand = `aws-vault exec ${ENV} -- aws ssm start-session --region ${region} --target ${instanceId} --document-name AWS-StartPortForwardingSessionToRemoteHost --parameters "host=${rdsEndpoint},portNumber='${remotePort}',localPortNumber='${portNumber}'" --cli-connect-timeout 0`
 
   console.log('Starting port forwarding session...')
   const child = exec(portForwardingCommand)
@@ -196,9 +239,9 @@ function executePortForwardingCommand (ENV, instanceId, rdsEndpoint, portNumber)
   return child
 }
 
-async function startPortForwarding (ENV, instanceId, rdsEndpoint, portNumber, retryCount = 0, maxRetries = RETRY_CONFIG.PORT_FORWARDING_MAX_RETRIES) {
+async function startPortForwardingWithConfig (ENV, instanceId, rdsEndpoint, portNumber, remotePort, region, retryCount = 0, maxRetries = RETRY_CONFIG.PORT_FORWARDING_MAX_RETRIES) {
   return new Promise((resolve, reject) => {
-    const child = executePortForwardingCommand(ENV, instanceId, rdsEndpoint, portNumber)
+    const child = executePortForwardingCommand(ENV, instanceId, rdsEndpoint, portNumber, remotePort, region)
     const sessionState = monitorPortForwardingSession(child)
 
     child.on('close', async (code) => {
@@ -208,7 +251,7 @@ async function startPortForwarding (ENV, instanceId, rdsEndpoint, portNumber, re
       try {
         // Handle TargetNotConnected error with retry
         if (code === 254 && sessionState.targetNotConnectedError && retryCount < maxRetries) {
-          await handleTargetNotConnectedError(ENV, instanceId, rdsEndpoint, portNumber, retryCount, maxRetries)
+          await handleTargetNotConnectedError(ENV, instanceId, rdsEndpoint, portNumber, remotePort, region, retryCount, maxRetries)
           resolve()
         } else if (code !== 0) {
           console.log(`Port forwarding session ended with code ${code}`)
@@ -225,19 +268,116 @@ async function startPortForwarding (ENV, instanceId, rdsEndpoint, portNumber, re
   })
 }
 
+// Legacy function for backward compatibility
+async function startPortForwarding (ENV, instanceId, rdsEndpoint, portNumber, retryCount = 0, maxRetries = RETRY_CONFIG.PORT_FORWARDING_MAX_RETRIES) {
+  return startPortForwardingWithConfig(ENV, instanceId, rdsEndpoint, portNumber, '5432', 'us-east-2', retryCount, maxRetries)
+}
+
+async function getRdsEndpoint (ENV, projectConfig) {
+  const { region, rdsType, rdsPattern } = projectConfig
+
+  if (rdsType === 'cluster') {
+    // Aurora cluster lookup
+    const rdsEndpointCommand = `aws-vault exec ${ENV} -- aws rds describe-db-clusters --region ${region} --query "DBClusters[?Status=='available' && ends_with(DBClusterIdentifier, '${rdsPattern}')].Endpoint | [0]" --output text`
+    return await runCommand(rdsEndpointCommand)
+  } else {
+    // Single RDS instance lookup
+    const rdsEndpointCommand = `aws-vault exec ${ENV} -- aws rds describe-db-instances --region ${region} --query "DBInstances[?DBInstanceStatus=='available' && contains(DBInstanceIdentifier, '${rdsPattern}')].Endpoint.Address | [0]" --output text`
+    return await runCommand(rdsEndpointCommand)
+  }
+}
+
+async function getRdsPort (ENV, projectConfig) {
+  const { region, rdsType, rdsPattern } = projectConfig
+
+  if (rdsType === 'cluster') {
+    const portCommand = `aws-vault exec ${ENV} -- aws rds describe-db-clusters --region ${region} --query "DBClusters[?Status=='available' && ends_with(DBClusterIdentifier, '${rdsPattern}')].Port | [0]" --output text`
+    return await runCommand(portCommand) || '5432'
+  } else {
+    const portCommand = `aws-vault exec ${ENV} -- aws rds describe-db-instances --region ${region} --query "DBInstances[?DBInstanceStatus=='available' && contains(DBInstanceIdentifier, '${rdsPattern}')].Endpoint.Port | [0]" --output text`
+    return await runCommand(portCommand) || '5432'
+  }
+}
+
+function getProfilesForProject (allProfiles, projectConfig, allProjectConfigs) {
+  const { profileFilter } = projectConfig
+
+  if (profileFilter) {
+    // Project has explicit filter - return profiles starting with filter
+    return 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(env =>
+      !otherFilters.some(filter => env.startsWith(filter))
+    )
+  }
+}
+
 async function main () {
   // Setup process cleanup handlers
   setupProcessCleanup()
 
+  // Check for updates (non-blocking)
+  await checkForUpdates()
+
   try {
-    const ENVS = await readAwsConfig()
+    // Read all AWS profiles first
+    const allProfiles = await readAwsConfig()
 
-    if (ENVS.length === 0) {
+    if (allProfiles.length === 0) {
       console.error('No environments found in AWS config file.')
       return
     }
 
-    const answers = await inquirer.prompt([
+    // Step 1: Filter projects based on available profiles
+    const projectChoices = Object.entries(PROJECT_CONFIGS)
+      .filter(([key, config]) => {
+        const matchingProfiles = getProfilesForProject(allProfiles, config, PROJECT_CONFIGS)
+        return matchingProfiles.length > 0
+      })
+      .map(([key, config]) => ({
+        name: config.name,
+        value: key
+      }))
+
+    if (projectChoices.length === 0) {
+      console.error('No projects available for the configured AWS profiles.')
+      return
+    }
+
+    // Skip project selection if only one project available
+    let projectKey
+    if (projectChoices.length === 1) {
+      projectKey = projectChoices[0].value
+      console.log(`Auto-selected project: ${projectChoices[0].name}`)
+    } else {
+      const projectAnswer = await inquirer.prompt([
+        {
+          type: 'select',
+          name: 'project',
+          message: 'Please select the project:',
+          choices: projectChoices,
+        },
+      ])
+      projectKey = projectAnswer.project
+    }
+
+    const projectConfig = PROJECT_CONFIGS[projectKey]
+    const { region, database, secretPrefix, envPortMapping, defaultPort } = projectConfig
+
+    // Step 2: Get profiles for selected project
+    let ENVS = getProfilesForProject(allProfiles, projectConfig, PROJECT_CONFIGS)
+
+    if (ENVS.length === 0) {
+      console.error('No AWS profiles found for this project.')
+      return
+    }
+
+    const envAnswer = await inquirer.prompt([
       {
         type: 'select',
         name: 'ENV',
@@ -246,20 +386,24 @@ async function main () {
       },
     ])
 
-    const ENV = answers.ENV
+    const ENV = envAnswer.ENV
+
+    // Determine local port number
     const allEnvSuffixes = Object.keys(envPortMapping).sort((a, b) => b.length - a.length)
-    const matchedSuffix = allEnvSuffixes.find(suffix => ENV.endsWith(suffix))
-    const portNumber = envPortMapping[matchedSuffix] || '5432'
+    const matchedSuffix = allEnvSuffixes.find(suffix => ENV.endsWith(suffix)) ||
+                          allEnvSuffixes.find(suffix => ENV === suffix)
+    const portNumber = envPortMapping[matchedSuffix] || defaultPort
 
-    const secretsListCommand = `aws-vault exec ${ENV} -- aws secretsmanager list-secrets --region ${REGION} --query "SecretList[?starts_with(Name, 'rds!cluster')].Name | [0]" --output text`
+    // Get RDS credentials from Secrets Manager
+    const secretsListCommand = `aws-vault exec ${ENV} -- aws secretsmanager list-secrets --region ${region} --query "SecretList[?starts_with(Name, '${secretPrefix}')].Name | [0]" --output text`
     const SECRET_NAME = await runCommand(secretsListCommand)
 
-    if (!SECRET_NAME) {
-      console.error('No secret found with name starting with rds!cluster.')
+    if (!SECRET_NAME || SECRET_NAME === 'None') {
+      console.error(`No secret found with name starting with '${secretPrefix}'.`)
       return
     }
 
-    const secretsGetCommand = `aws-vault exec ${ENV} -- aws secretsmanager get-secret-value --region ${REGION} --secret-id "${SECRET_NAME}" --query SecretString --output text`
+    const secretsGetCommand = `aws-vault exec ${ENV} -- aws secretsmanager get-secret-value --region ${region} --secret-id "${SECRET_NAME}" --query SecretString --output text`
     const secretString = await runCommand(secretsGetCommand)
 
     if (!secretString) {
@@ -281,14 +425,15 @@ async function main () {
     const USERNAME = CREDENTIALS.username
     const PASSWORD = CREDENTIALS.password
 
-    console.log(`Your connection details:
+    console.log(`\nYour connection details:
       Host: localhost
       Port: ${portNumber}
       User: ${USERNAME}
-      Database: ${TABLE_NAME}
-      Password: ${PASSWORD}`)
+      Database: ${database}
+      Password: ${PASSWORD}\n`)
 
-    const instanceIdCommand = `aws-vault exec ${ENV} -- aws ec2 describe-instances --region ${REGION} --filters "Name=tag:Name,Values='*bastion*'" "Name=instance-state-name,Values=running" --query "Reservations[].Instances[].[InstanceId] | [0][0]" --output text`
+    // Find bastion instance
+    const instanceIdCommand = `aws-vault exec ${ENV} -- aws ec2 describe-instances --region ${region} --filters "Name=tag:Name,Values='*bastion*'" "Name=instance-state-name,Values=running" --query "Reservations[].Instances[].[InstanceId] | [0][0]" --output text`
     const INSTANCE_ID = await runCommand(instanceIdCommand)
 
     if (!INSTANCE_ID || INSTANCE_ID === 'None') {
@@ -296,15 +441,18 @@ async function main () {
       return
     }
 
-    const rdsEndpointCommand = `aws-vault exec ${ENV} -- aws rds describe-db-clusters --region ${REGION} --query "DBClusters[?Status=='available' && ends_with(DBClusterIdentifier, '-rds-aurora')].Endpoint | [0]" --output text`
-    const RDS_ENDPOINT = await runCommand(rdsEndpointCommand)
+    // Get RDS endpoint
+    const RDS_ENDPOINT = await getRdsEndpoint(ENV, projectConfig)
 
     if (!RDS_ENDPOINT || RDS_ENDPOINT === 'None') {
       console.error('Failed to find the RDS endpoint.')
       return
     }
 
-    await startPortForwarding(ENV, INSTANCE_ID, RDS_ENDPOINT, portNumber)
+    // Get RDS port (remote port)
+    const rdsPort = await getRdsPort(ENV, projectConfig)
+
+    await startPortForwardingWithConfig(ENV, INSTANCE_ID, RDS_ENDPOINT, portNumber, rdsPort, region)
   } catch (error) {
     console.error(`Error: ${error.message}`)
     console.error('Exiting due to unhandled error')

package/envPortMapping.js

@@ -1,29 +1,54 @@
-// Define a mapping of environment suffixes to port numbers
-export const envPortMapping = {
-  dev: '5433',
-  stage: '5434',
-  'pre-prod': '5435',
-  prod: '5436',
-  dev2: '5437',
-  stage2: '5438',
-  sandbox: '5439',
-  'perf-dev': '5440',
-  support: '5441',
-  team1: '5442',
-  team2: '5443',
-  team3: '5444',
-  team4: '5445',
-  team5: '5446',
-  qa1: '5447',
-  qa2: '5448',
-  qa3: '5449',
-  qa4: '5450',
-  qa5: '5451',
-  hotfix: '5452'
+// Project configurations
+export const PROJECT_CONFIGS = {
+  tln: {
+    name: 'TLN (EMR)',
+    region: 'us-east-2',
+    database: 'emr',
+    secretPrefix: 'rds!cluster',
+    rdsType: 'cluster', // Aurora cluster
+    rdsPattern: '-rds-aurora', // DBClusterIdentifier ends with this
+    profileFilter: null, // Show all profiles (legacy behavior)
+    envPortMapping: {
+      dev: '5433',
+      stage: '5434',
+      'pre-prod': '5435',
+      prod: '5436',
+      dev2: '5437',
+      stage2: '5438',
+      sandbox: '5439',
+      'perf-dev': '5440',
+      support: '5441',
+      team1: '5442',
+      team2: '5443',
+      team3: '5444',
+      team4: '5445',
+      team5: '5446',
+      qa1: '5447',
+      qa2: '5448',
+      qa3: '5449',
+      qa4: '5450',
+      qa5: '5451',
+      hotfix: '5452'
+    },
+    defaultPort: '5432'
+  },
+  covered: {
+    name: 'Covered (Healthcare)',
+    region: 'us-west-1',
+    database: 'covered',
+    secretPrefix: 'rds!db',
+    rdsType: 'instance', // Single RDS instance (not Aurora)
+    rdsPattern: 'covered-db', // DBInstanceIdentifier contains this
+    profileFilter: 'covered', // Only show profiles starting with 'covered'
+    envPortMapping: {
+      'covered': '5460',
+      'covered-staging': '5461'
+    },
+    defaultPort: '5460'
+  }
 }
 
-// Define the table name
-export const TABLE_NAME = 'emr'
-
-// Define the AWS region
-export const REGION = 'us-east-2'
+// Legacy exports for backward compatibility
+export const envPortMapping = PROJECT_CONFIGS.tln.envPortMapping
+export const TABLE_NAME = PROJECT_CONFIGS.tln.database
+export const REGION = PROJECT_CONFIGS.tln.region

package/package.json

@@ -1,11 +1,16 @@
 {
   "name": "rds_ssm_connect",
-  "version": "1.5.2",
+  "version": "1.6.2",
   "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yarka-guru/connection_app.git"
+  },
   "dependencies": {
     "@aws-sdk/client-ec2": "^3.980.0",
     "@aws-sdk/client-rds": "^3.980.0",
     "@aws-sdk/client-ssm": "^3.980.0",
+    "fast-xml-parser": "^5.3.4",
     "glob": "^13.0.0",
     "inquirer": "^13.2.2",
     "rimraf": "^6.1.2"