@stacksjs/ts-cloud 0.1.8 → 0.1.9

package/src/aws/sts.ts

@@ -0,0 +1,92 @@
+/**
+ * AWS STS Operations
+ * Direct API calls without AWS CLI dependency
+ */
+
+import { AWSClient } from './client'
+
+export interface CallerIdentity {
+  UserId?: string
+  Account?: string
+  Arn?: string
+}
+
+/**
+ * STS (Security Token Service) management using direct API calls
+ */
+export class STSClient {
+  private client: AWSClient
+  private region: string
+
+  constructor(region: string = 'us-east-1', profile?: string) {
+    this.region = region
+    this.client = new AWSClient()
+  }
+
+  /**
+   * Get information about the IAM identity whose credentials are used to call the operation
+   */
+  async getCallerIdentity(): Promise<CallerIdentity> {
+    const result = await this.client.request({
+      service: 'sts',
+      region: this.region,
+      method: 'POST',
+      path: '/',
+      headers: {
+        'Content-Type': 'application/x-www-form-urlencoded',
+      },
+      body: 'Action=GetCallerIdentity&Version=2011-06-15',
+    })
+
+    // Parse XML response
+    // The response will be in XML format like:
+    // <GetCallerIdentityResponse>
+    //   <GetCallerIdentityResult>
+    //     <Account>123456789012</Account>
+    //     <UserId>AIDAI...</UserId>
+    //     <Arn>arn:aws:iam::...</Arn>
+    //   </GetCallerIdentityResult>
+    // </GetCallerIdentityResponse>
+
+    if (typeof result === 'string') {
+      const accountMatch = result.match(/<Account>(\d+)<\/Account>/)
+      const userIdMatch = result.match(/<UserId>([^<]+)<\/UserId>/)
+      const arnMatch = result.match(/<Arn>([^<]+)<\/Arn>/)
+
+      return {
+        Account: accountMatch?.[1],
+        UserId: userIdMatch?.[1],
+        Arn: arnMatch?.[1],
+      }
+    }
+
+    // Handle parsed XML response - the structure can be either:
+    // 1. { GetCallerIdentityResponse: { GetCallerIdentityResult: { Account, UserId, Arn } } }
+    // 2. { GetCallerIdentityResult: { Account, UserId, Arn } }  (more common)
+    const identityResult = result?.GetCallerIdentityResponse?.GetCallerIdentityResult
+      || result?.GetCallerIdentityResult
+
+    if (identityResult) {
+      return {
+        Account: String(identityResult.Account),
+        UserId: identityResult.UserId,
+        Arn: identityResult.Arn,
+      }
+    }
+
+    // Direct object structure
+    if (result?.Account) {
+      return {
+        Account: String(result.Account),
+        UserId: result.UserId,
+        Arn: result.Arn,
+      }
+    }
+
+    return {
+      Account: undefined,
+      UserId: undefined,
+      Arn: undefined,
+    }
+  }
+}

package/src/aws/support.ts

@@ -0,0 +1,391 @@
+/**
+ * AWS Support API Operations
+ * Automates support ticket creation for service limit increases and sandbox exits
+ */
+
+import { AWSClient } from './client'
+
+export interface SupportCase {
+  caseId?: string
+  displayId?: string
+  subject?: string
+  status?: string
+  serviceCode?: string
+  categoryCode?: string
+  severityCode?: string
+  submittedBy?: string
+  timeCreated?: string
+  recentCommunications?: {
+    communications?: Array<{
+      body?: string
+      submittedBy?: string
+      timeCreated?: string
+    }>
+  }
+}
+
+export interface CreateCaseParams {
+  subject: string
+  communicationBody: string
+  serviceCode: string
+  categoryCode: string
+  severityCode?: 'low' | 'normal' | 'high' | 'urgent' | 'critical'
+  ccEmailAddresses?: string[]
+  language?: string
+  issueType?: 'customer-service' | 'technical'
+  attachmentSetId?: string
+}
+
+export interface SupportService {
+  code: string
+  name: string
+  categories?: Array<{
+    code: string
+    name: string
+  }>
+}
+
+/**
+ * AWS Support client for creating and managing support cases
+ */
+export class SupportClient {
+  private client: AWSClient
+  private region: string
+
+  constructor(region: string = 'us-east-1') {
+    this.region = region
+    this.client = new AWSClient()
+  }
+
+  /**
+   * Create a new support case
+   */
+  async createCase(params: CreateCaseParams): Promise<{ caseId?: string }> {
+    const result = await this.client.request({
+      service: 'support',
+      region: this.region,
+      method: 'POST',
+      path: '/',
+      headers: {
+        'Content-Type': 'application/x-amz-json-1.1',
+        'X-Amz-Target': 'AWSSupport_20130415.CreateCase',
+      },
+      body: JSON.stringify({
+        subject: params.subject,
+        communicationBody: params.communicationBody,
+        serviceCode: params.serviceCode,
+        categoryCode: params.categoryCode,
+        severityCode: params.severityCode || 'normal',
+        ccEmailAddresses: params.ccEmailAddresses,
+        language: params.language || 'en',
+        issueType: params.issueType || 'customer-service',
+        attachmentSetId: params.attachmentSetId,
+      }),
+    })
+
+    return result as { caseId?: string }
+  }
+
+  /**
+   * Get details of a support case
+   */
+  async describeCase(caseId: string): Promise<SupportCase | null> {
+    const result = await this.client.request({
+      service: 'support',
+      region: this.region,
+      method: 'POST',
+      path: '/',
+      headers: {
+        'Content-Type': 'application/x-amz-json-1.1',
+        'X-Amz-Target': 'AWSSupport_20130415.DescribeCases',
+      },
+      body: JSON.stringify({
+        caseIdList: [caseId],
+        includeResolvedCases: true,
+        includeCommunications: true,
+      }),
+    })
+
+    const cases = (result as { cases?: SupportCase[] }).cases
+    return cases?.[0] || null
+  }
+
+  /**
+   * List all support cases
+   */
+  async listCases(options?: {
+    includeResolved?: boolean
+    maxResults?: number
+    nextToken?: string
+  }): Promise<{ cases: SupportCase[], nextToken?: string }> {
+    const result = await this.client.request({
+      service: 'support',
+      region: this.region,
+      method: 'POST',
+      path: '/',
+      headers: {
+        'Content-Type': 'application/x-amz-json-1.1',
+        'X-Amz-Target': 'AWSSupport_20130415.DescribeCases',
+      },
+      body: JSON.stringify({
+        includeResolvedCases: options?.includeResolved ?? false,
+        maxResults: options?.maxResults,
+        nextToken: options?.nextToken,
+        includeCommunications: true,
+      }),
+    })
+
+    return result as { cases: SupportCase[], nextToken?: string }
+  }
+
+  /**
+   * Add a communication to an existing case
+   */
+  async addCommunication(caseId: string, message: string, ccEmailAddresses?: string[]): Promise<boolean> {
+    const result = await this.client.request({
+      service: 'support',
+      region: this.region,
+      method: 'POST',
+      path: '/',
+      headers: {
+        'Content-Type': 'application/x-amz-json-1.1',
+        'X-Amz-Target': 'AWSSupport_20130415.AddCommunicationToCase',
+      },
+      body: JSON.stringify({
+        caseId,
+        communicationBody: message,
+        ccEmailAddresses,
+      }),
+    })
+
+    return (result as { result?: boolean }).result ?? true
+  }
+
+  /**
+   * Resolve a support case
+   */
+  async resolveCase(caseId: string): Promise<{ initialCaseStatus?: string, finalCaseStatus?: string }> {
+    const result = await this.client.request({
+      service: 'support',
+      region: this.region,
+      method: 'POST',
+      path: '/',
+      headers: {
+        'Content-Type': 'application/x-amz-json-1.1',
+        'X-Amz-Target': 'AWSSupport_20130415.ResolveCase',
+      },
+      body: JSON.stringify({
+        caseId,
+      }),
+    })
+
+    return result as { initialCaseStatus?: string, finalCaseStatus?: string }
+  }
+
+  /**
+   * Get available services and categories for support cases
+   */
+  async describeServices(serviceCodeList?: string[]): Promise<SupportService[]> {
+    const result = await this.client.request({
+      service: 'support',
+      region: this.region,
+      method: 'POST',
+      path: '/',
+      headers: {
+        'Content-Type': 'application/x-amz-json-1.1',
+        'X-Amz-Target': 'AWSSupport_20130415.DescribeServices',
+      },
+      body: JSON.stringify({
+        serviceCodeList,
+        language: 'en',
+      }),
+    })
+
+    return (result as { services?: SupportService[] }).services || []
+  }
+
+  /**
+   * Get available severity levels
+   */
+  async describeSeverityLevels(): Promise<Array<{ code: string, name: string }>> {
+    const result = await this.client.request({
+      service: 'support',
+      region: this.region,
+      method: 'POST',
+      path: '/',
+      headers: {
+        'Content-Type': 'application/x-amz-json-1.1',
+        'X-Amz-Target': 'AWSSupport_20130415.DescribeSeverityLevels',
+      },
+      body: JSON.stringify({
+        language: 'en',
+      }),
+    })
+
+    return (result as { severityLevels?: Array<{ code: string, name: string }> }).severityLevels || []
+  }
+}
+
+export interface SmsSandboxExitParams {
+  companyName: string
+  useCase: string
+  expectedMonthlyVolume: number
+  websiteUrl?: string
+}
+
+export interface SmsSpendLimitIncreaseParams {
+  companyName: string
+  currentLimit: number
+  requestedLimit: number
+  useCase: string
+}
+
+export interface SesSandboxExitParams {
+  companyName: string
+  websiteUrl: string
+  useCase: string
+  expectedDailyVolume: number
+}
+
+export interface ConnectPhoneNumberIncreaseParams {
+  companyName: string
+  instanceId: string
+  currentLimit: number
+  requestedLimit: number
+  useCase: string
+}
+
+/**
+ * Pre-built support case templates for common requests
+ */
+export const SupportTemplates = {
+  /**
+   * Request to exit SMS sandbox
+   */
+  smsSandboxExit: (params: SmsSandboxExitParams): CreateCaseParams => ({
+    subject: 'Request to exit SMS sandbox for production use',
+    serviceCode: 'service-limit-increase',
+    categoryCode: 'service-limit-increase-sms-pinpoint',
+    severityCode: 'normal',
+    communicationBody: `Hello,
+
+I would like to request that our AWS account be moved out of the SMS sandbox to enable production SMS messaging.
+
+**Company/Project**: ${params.companyName}
+**Website**: ${params.websiteUrl || 'N/A'}
+
+**Use Case**:
+${params.useCase}
+
+**Expected Monthly SMS Volume**: ${params.expectedMonthlyVolume.toLocaleString()} messages
+
+**Message Types**:
+- Transactional (verification codes, order confirmations, etc.)
+- Account notifications
+
+**Opt-out Handling**:
+We have implemented standard opt-out handling with STOP, UNSUBSCRIBE, CANCEL, END, and QUIT keywords.
+
+**Compliance**:
+- We will only send SMS to users who have explicitly opted in
+- We will include opt-out instructions in promotional messages
+- We will honor all opt-out requests immediately
+
+Thank you for reviewing this request.`,
+  }),
+
+  /**
+   * Request to increase SMS spending limit
+   */
+  smsSpendLimitIncrease: (params: SmsSpendLimitIncreaseParams): CreateCaseParams => ({
+    subject: `Request to increase SMS spending limit from $${params.currentLimit} to $${params.requestedLimit}`,
+    serviceCode: 'service-limit-increase',
+    categoryCode: 'service-limit-increase-sms-pinpoint',
+    severityCode: 'normal',
+    communicationBody: `Hello,
+
+I would like to request an increase to our monthly SMS spending limit.
+
+**Company/Project**: ${params.companyName}
+
+**Current Limit**: $${params.currentLimit}/month
+**Requested Limit**: $${params.requestedLimit}/month
+
+**Justification**:
+${params.useCase}
+
+**Message Types**:
+- Transactional notifications
+- Verification codes
+- Account alerts
+
+We have proper opt-out handling in place and comply with all SMS messaging regulations.
+
+Thank you for reviewing this request.`,
+  }),
+
+  /**
+   * Request SES production access (exit sandbox)
+   */
+  sesSandboxExit: (params: SesSandboxExitParams): CreateCaseParams => ({
+    subject: 'Request to move out of Amazon SES sandbox',
+    serviceCode: 'service-limit-increase',
+    categoryCode: 'service-limit-increase-ses-702',
+    severityCode: 'normal',
+    communicationBody: `Hello,
+
+I would like to request that our AWS account be moved out of the Amazon SES sandbox to enable production email sending.
+
+**Company/Project**: ${params.companyName}
+**Website**: ${params.websiteUrl}
+
+**Use Case**:
+${params.useCase}
+
+**Expected Daily Email Volume**: ${params.expectedDailyVolume.toLocaleString()} emails
+
+**Email Types**:
+- Transactional emails (password resets, order confirmations, etc.)
+- Account notifications
+- System alerts
+
+**Compliance**:
+- We will only send emails to users who have explicitly opted in
+- We have implemented proper bounce and complaint handling
+- We will include unsubscribe links in all marketing emails
+- We maintain a clean mailing list and honor all unsubscribe requests
+
+**Technical Setup**:
+- Domain verification: Complete (DKIM, SPF, DMARC configured)
+- Bounce/complaint handling: SNS notifications configured
+- Email authentication: Fully implemented
+
+Thank you for reviewing this request.`,
+  }),
+
+  /**
+   * Request Connect phone number limit increase
+   */
+  connectPhoneNumberIncrease: (params: ConnectPhoneNumberIncreaseParams): CreateCaseParams => ({
+    subject: `Request to increase Amazon Connect phone number limit from ${params.currentLimit} to ${params.requestedLimit}`,
+    serviceCode: 'service-limit-increase',
+    categoryCode: 'service-limit-increase-connect',
+    severityCode: 'normal',
+    communicationBody: `Hello,
+
+I would like to request an increase to our Amazon Connect phone number limit.
+
+**Company/Project**: ${params.companyName}
+**Connect Instance ID**: ${params.instanceId}
+
+**Current Limit**: ${params.currentLimit} phone numbers
+**Requested Limit**: ${params.requestedLimit} phone numbers
+
+**Use Case**:
+${params.useCase}
+
+Thank you for reviewing this request.`,
+  }),
+}
+
+export default SupportClient

package/src/aws/test-imap.ts

@@ -0,0 +1,86 @@
+#!/usr/bin/env bun
+/**
+ * Test script to run the IMAP server locally
+ * This reads emails from S3 and serves them via IMAP
+ *
+ * Usage:
+ *   bun run src/aws/test-imap.ts
+ *
+ * Then configure Mail.app:
+ *   IMAP Server: localhost
+ *   Port: 1143 (or 143 if running as root)
+ *   Username: chris
+ *   Password: test123
+ */
+
+import { startImapServer } from './imap-server'
+
+async function main() {
+  console.log('Starting IMAP-to-S3 bridge server...')
+  console.log('')
+
+  const port = Number.parseInt(process.env.IMAP_PORT || '1143', 10)
+  const sslPort = Number.parseInt(process.env.IMAPS_PORT || '1993', 10)
+
+  const server = await startImapServer({
+    port, // Use 1143 for non-root, or 143 if running as root
+    sslPort, // Use 1993 for non-root, or 993 if running as root
+    host: '0.0.0.0',
+    region: 'us-east-1',
+    bucket: 'stacks-production-email',
+    prefix: 'incoming/',
+    domain: 'stacksjs.com',
+    users: {
+      chris: {
+        password: 'test123',
+        email: 'chris@stacksjs.com',
+      },
+      blake: {
+        password: 'test123',
+        email: 'blake@stacksjs.com',
+      },
+      glenn: {
+        password: 'test123',
+        email: 'glenn@stacksjs.com',
+      },
+    },
+    // To enable TLS, provide certificate paths:
+    // tls: {
+    //   key: '/path/to/key.pem',
+    //   cert: '/path/to/cert.pem',
+    // },
+  })
+
+  console.log('')
+  console.log('='.repeat(60))
+  console.log('IMAP-to-S3 Bridge Server Running')
+  console.log('='.repeat(60))
+  console.log('')
+  console.log('Mail.app Settings:')
+  console.log('  Account Type:    IMAP')
+  console.log('  Incoming Server: localhost')
+  console.log(`  Port:            ${port}`)
+  console.log('  Username:        chris (or blake, glenn)')
+  console.log('  Password:        test123')
+  console.log(`  SSL:             Off (or ${sslPort} with SSL)`)
+  console.log('')
+  console.log('For production, use ports 143/993 (requires root or port forwarding)')
+  console.log('Set IMAP_PORT and IMAPS_PORT environment variables to change ports')
+  console.log('')
+  console.log('Press Ctrl+C to stop')
+
+  // Handle graceful shutdown
+  process.on('SIGINT', async () => {
+    console.log('\nShutting down...')
+    await server.stop()
+    process.exit(0)
+  })
+
+  process.on('SIGTERM', async () => {
+    console.log('\nShutting down...')
+    await server.stop()
+    process.exit(0)
+  })
+}
+
+main().catch(console.error)