cleanup

Author: waleedlatif1

apps/docs/content/docs/en/tools/textract.mdx

@@ -27,7 +27,7 @@ In Sim, the AWS Textract integration empowers your agents to intelligently proce
 
 ## Usage Instructions
 
-Integrate AWS Textract into your workflow to extract text, tables, forms, and key-value pairs from documents. Sync mode supports JPEG, PNG, and single-page PDF. Async mode supports multi-page PDF and TIFF via S3.
+Integrate AWS Textract into your workflow to extract text, tables, forms, and key-value pairs from documents. Single-page mode supports JPEG, PNG, and single-page PDF. Multi-page mode supports multi-page PDF and TIFF.
 
 
 
@@ -45,8 +45,8 @@ Parse documents using AWS Textract OCR and document analysis
 | `secretAccessKey` | string | Yes | AWS Secret Access Key |
 | `region` | string | Yes | AWS region for Textract service \(e.g., us-east-1\) |
 | `processingMode` | string | No | Document type: single-page or multi-page. Defaults to single-page. |
-| `filePath` | string | No | URL to a document to be processed \(JPEG, PNG, PDF, or TIFF\). Required for sync mode. |
-| `s3Uri` | string | No | S3 URI for async processing \(s3://bucket/key\). Required for async mode with S3 input. |
+| `filePath` | string | No | URL to a document to be processed \(JPEG, PNG, or single-page PDF\). |
+| `s3Uri` | string | No | S3 URI for multi-page processing \(s3://bucket/key\). |
 | `fileUpload` | object | No | File upload data from file-upload component |
 | `featureTypes` | array | No | Feature types to detect: TABLES, FORMS, QUERIES, SIGNATURES, LAYOUT. If not specified, only text detection is performed. |
 | `items` | string | No | Feature type |

apps/sim/app/api/tools/textract/parse/route.ts

@@ -49,9 +49,6 @@ const TextractParseSchema = z
     }
   })
 
-/**
- * Generate AWS Signature Version 4 signing key
- */
 function getSignatureKey(
   key: string,
   dateStamp: string,
@@ -309,7 +306,7 @@ export async function POST(request: NextRequest) {
         return NextResponse.json(
           {
             success: false,
-            error: 'S3 URI or file path is required for async processing',
+            error: 'S3 URI or file path is required for multi-page processing',
           },
           { status: 400 }
         )
@@ -338,7 +335,7 @@ export async function POST(request: NextRequest) {
         return NextResponse.json(
           {
             success: false,
-            error: 'Async mode requires an S3 URI (s3://bucket/key) or an uploaded file',
+            error: 'Multi-page mode requires an S3 URI (s3://bucket/key) or an uploaded file',
           },
           { status: 400 }
         )
@@ -425,7 +422,7 @@ export async function POST(request: NextRequest) {
       return NextResponse.json(
         {
           success: false,
-          error: 'File path is required for sync processing',
+          error: 'File path is required for single-page processing',
         },
         { status: 400 }
       )

apps/sim/blocks/blocks/textract.ts

@@ -7,7 +7,7 @@ export const TextractBlock: BlockConfig<TextractParserOutput> = {
   name: 'AWS Textract',
   description: 'Extract text, tables, and forms from documents',
   authMode: AuthMode.ApiKey,
-  longDescription: `Integrate AWS Textract into your workflow to extract text, tables, forms, and key-value pairs from documents. Sync mode supports JPEG, PNG, and single-page PDF. Async mode supports multi-page PDF and TIFF via S3.`,
+  longDescription: `Integrate AWS Textract into your workflow to extract text, tables, forms, and key-value pairs from documents. Single-page mode supports JPEG, PNG, and single-page PDF. Multi-page mode supports multi-page PDF and TIFF.`,
   docsLink: 'https://docs.sim.ai/tools/textract',
   category: 'tools',
   bgColor: 'linear-gradient(135deg, #055F4E 0%, #56C0A7 100%)',
@@ -180,7 +180,7 @@ export const TextractBlock: BlockConfig<TextractParserOutput> = {
           const asyncInputMethod = params.asyncInputMethod || 's3'
           if (asyncInputMethod === 's3') {
             if (!params.s3Uri || params.s3Uri.trim() === '') {
-              throw new Error('S3 URI is required for async processing')
+              throw new Error('S3 URI is required for multi-page processing')
             }
             parameters.s3Uri = params.s3Uri.trim()
           } else if (asyncInputMethod === 'upload') {
@@ -220,12 +220,12 @@ export const TextractBlock: BlockConfig<TextractParserOutput> = {
   },
   inputs: {
     processingMode: { type: 'string', description: 'Document type: single-page or multi-page' },
-    inputMethod: { type: 'string', description: 'Input method selection for sync mode' },
-    asyncInputMethod: { type: 'string', description: 'Input method selection for async mode' },
+    inputMethod: { type: 'string', description: 'Input method selection for single-page mode' },
+    asyncInputMethod: { type: 'string', description: 'Input method selection for multi-page mode' },
     filePath: { type: 'string', description: 'Document URL' },
-    s3Uri: { type: 'string', description: 'S3 URI for async processing (s3://bucket/key)' },
-    fileUpload: { type: 'json', description: 'Uploaded document file for sync mode' },
-    asyncFileUpload: { type: 'json', description: 'Uploaded document file for async mode' },
+    s3Uri: { type: 'string', description: 'S3 URI for multi-page processing (s3://bucket/key)' },
+    fileUpload: { type: 'json', description: 'Uploaded document file for single-page mode' },
+    asyncFileUpload: { type: 'json', description: 'Uploaded document file for multi-page mode' },
     extractTables: { type: 'boolean', description: 'Extract tables from document' },
     extractForms: { type: 'boolean', description: 'Extract form key-value pairs' },
     detectSignatures: { type: 'boolean', description: 'Detect signatures' },

apps/sim/lib/core/security/input-validation.test.ts

@@ -4,6 +4,7 @@ import {
   createPinnedUrl,
   validateAirtableId,
   validateAlphanumericId,
+  validateAwsRegion,
   validateEnum,
   validateExternalUrl,
   validateFileExtension,
@@ -17,6 +18,7 @@ import {
   validateNumericId,
   validatePathSegment,
   validateProxyUrl,
+  validateS3BucketName,
   validateUrlWithDNS,
 } from '@/lib/core/security/input-validation'
 import { sanitizeForLogging } from '@/lib/core/security/redaction'
@@ -1192,3 +1194,216 @@ describe('validateAirtableId', () => {
     })
   })
 })
+
+describe('validateAwsRegion', () => {
+  describe('valid regions', () => {
+    it.concurrent('should accept us-east-1', () => {
+      const result = validateAwsRegion('us-east-1')
+      expect(result.isValid).toBe(true)
+      expect(result.sanitized).toBe('us-east-1')
+    })
+
+    it.concurrent('should accept us-west-2', () => {
+      const result = validateAwsRegion('us-west-2')
+      expect(result.isValid).toBe(true)
+    })
+
+    it.concurrent('should accept eu-west-1', () => {
+      const result = validateAwsRegion('eu-west-1')
+      expect(result.isValid).toBe(true)
+    })
+
+    it.concurrent('should accept ap-southeast-1', () => {
+      const result = validateAwsRegion('ap-southeast-1')
+      expect(result.isValid).toBe(true)
+    })
+
+    it.concurrent('should accept sa-east-1', () => {
+      const result = validateAwsRegion('sa-east-1')
+      expect(result.isValid).toBe(true)
+    })
+
+    it.concurrent('should accept me-south-1', () => {
+      const result = validateAwsRegion('me-south-1')
+      expect(result.isValid).toBe(true)
+    })
+
+    it.concurrent('should accept af-south-1', () => {
+      const result = validateAwsRegion('af-south-1')
+      expect(result.isValid).toBe(true)
+    })
+
+    it.concurrent('should accept regions with double-digit numbers', () => {
+      const result = validateAwsRegion('ap-northeast-12')
+      expect(result.isValid).toBe(true)
+    })
+  })
+
+  describe('invalid regions', () => {
+    it.concurrent('should reject null', () => {
+      const result = validateAwsRegion(null)
+      expect(result.isValid).toBe(false)
+      expect(result.error).toContain('required')
+    })
+
+    it.concurrent('should reject empty string', () => {
+      const result = validateAwsRegion('')
+      expect(result.isValid).toBe(false)
+      expect(result.error).toContain('required')
+    })
+
+    it.concurrent('should reject uppercase regions', () => {
+      const result = validateAwsRegion('US-EAST-1')
+      expect(result.isValid).toBe(false)
+    })
+
+    it.concurrent('should reject invalid format - missing number', () => {
+      const result = validateAwsRegion('us-east')
+      expect(result.isValid).toBe(false)
+    })
+
+    it.concurrent('should reject invalid format - wrong separators', () => {
+      const result = validateAwsRegion('us_east_1')
+      expect(result.isValid).toBe(false)
+    })
+
+    it.concurrent('should reject invalid format - too many parts', () => {
+      const result = validateAwsRegion('us-east-1-extra')
+      expect(result.isValid).toBe(false)
+    })
+
+    it.concurrent('should reject path traversal attempts', () => {
+      const result = validateAwsRegion('../etc/passwd')
+      expect(result.isValid).toBe(false)
+    })
+
+    it.concurrent('should reject arbitrary strings', () => {
+      const result = validateAwsRegion('not-a-region')
+      expect(result.isValid).toBe(false)
+    })
+
+    it.concurrent('should use custom param name in errors', () => {
+      const result = validateAwsRegion('', 'awsRegion')
+      expect(result.error).toContain('awsRegion')
+    })
+  })
+})
+
+describe('validateS3BucketName', () => {
+  describe('valid bucket names', () => {
+    it.concurrent('should accept simple bucket name', () => {
+      const result = validateS3BucketName('my-bucket')
+      expect(result.isValid).toBe(true)
+      expect(result.sanitized).toBe('my-bucket')
+    })
+
+    it.concurrent('should accept bucket name with numbers', () => {
+      const result = validateS3BucketName('bucket123')
+      expect(result.isValid).toBe(true)
+    })
+
+    it.concurrent('should accept bucket name with periods', () => {
+      const result = validateS3BucketName('my.bucket.name')
+      expect(result.isValid).toBe(true)
+    })
+
+    it.concurrent('should accept 3 character bucket name', () => {
+      const result = validateS3BucketName('abc')
+      expect(result.isValid).toBe(true)
+    })
+
+    it.concurrent('should accept 63 character bucket name', () => {
+      const result = validateS3BucketName('a'.repeat(63))
+      expect(result.isValid).toBe(true)
+    })
+
+    it.concurrent('should accept minimum valid bucket name (3 chars)', () => {
+      const result = validateS3BucketName('a1b')
+      expect(result.isValid).toBe(true)
+    })
+  })
+
+  describe('invalid bucket names - null/empty', () => {
+    it.concurrent('should reject null', () => {
+      const result = validateS3BucketName(null)
+      expect(result.isValid).toBe(false)
+      expect(result.error).toContain('required')
+    })
+
+    it.concurrent('should reject empty string', () => {
+      const result = validateS3BucketName('')
+      expect(result.isValid).toBe(false)
+      expect(result.error).toContain('required')
+    })
+  })
+
+  describe('invalid bucket names - length', () => {
+    it.concurrent('should reject 2 character bucket name', () => {
+      const result = validateS3BucketName('ab')
+      expect(result.isValid).toBe(false)
+      expect(result.error).toContain('between 3 and 63')
+    })
+
+    it.concurrent('should reject 64 character bucket name', () => {
+      const result = validateS3BucketName('a'.repeat(64))
+      expect(result.isValid).toBe(false)
+      expect(result.error).toContain('between 3 and 63')
+    })
+  })
+
+  describe('invalid bucket names - format', () => {
+    it.concurrent('should reject uppercase letters', () => {
+      const result = validateS3BucketName('MyBucket')
+      expect(result.isValid).toBe(false)
+    })
+
+    it.concurrent('should reject underscores', () => {
+      const result = validateS3BucketName('my_bucket')
+      expect(result.isValid).toBe(false)
+    })
+
+    it.concurrent('should reject starting with hyphen', () => {
+      const result = validateS3BucketName('-mybucket')
+      expect(result.isValid).toBe(false)
+    })
+
+    it.concurrent('should reject ending with hyphen', () => {
+      const result = validateS3BucketName('mybucket-')
+      expect(result.isValid).toBe(false)
+    })
+
+    it.concurrent('should reject starting with period', () => {
+      const result = validateS3BucketName('.mybucket')
+      expect(result.isValid).toBe(false)
+    })
+
+    it.concurrent('should reject ending with period', () => {
+      const result = validateS3BucketName('mybucket.')
+      expect(result.isValid).toBe(false)
+    })
+
+    it.concurrent('should reject consecutive periods', () => {
+      const result = validateS3BucketName('my..bucket')
+      expect(result.isValid).toBe(false)
+      expect(result.error).toContain('consecutive periods')
+    })
+
+    it.concurrent('should reject IP address format', () => {
+      const result = validateS3BucketName('192.168.1.1')
+      expect(result.isValid).toBe(false)
+      expect(result.error).toContain('IP address')
+    })
+
+    it.concurrent('should reject special characters', () => {
+      const result = validateS3BucketName('my@bucket')
+      expect(result.isValid).toBe(false)
+    })
+  })
+
+  describe('error messages', () => {
+    it.concurrent('should use custom param name in errors', () => {
+      const result = validateS3BucketName('', 's3Bucket')
+      expect(result.error).toContain('s3Bucket')
+    })
+  })
+})

apps/sim/tools/textract/parser.ts

@@ -40,15 +40,13 @@ export const textractParserTool: ToolConfig<TextractParserInput, TextractParserO
       type: 'string',
       required: false,
       visibility: 'user-only',
-      description:
-        'URL to a document to be processed (JPEG, PNG, PDF, or TIFF). Required for sync mode.',
+      description: 'URL to a document to be processed (JPEG, PNG, or single-page PDF).',
     },
     s3Uri: {
       type: 'string',
       required: false,
       visibility: 'user-only',
-      description:
-        'S3 URI for async processing (s3://bucket/key). Required for async mode with S3 input.',
+      description: 'S3 URI for multi-page processing (s3://bucket/key).',
     },
     fileUpload: {
       type: 'object',
@@ -144,13 +142,13 @@ export const textractParserTool: ToolConfig<TextractParserInput, TextractParserO
             if (uploadedFilePath.startsWith('/api/files/serve/')) {
               requestBody.filePath = uploadedFilePath
             } else {
-              throw new Error('Async mode with upload requires files stored in S3')
+              throw new Error('Multi-page mode with upload requires files stored in S3')
             }
           } else {
             throw new Error('Invalid file upload: Upload data is missing or invalid')
           }
         } else {
-          throw new Error('Async mode requires either an S3 URI or an uploaded file')
+          throw new Error('Multi-page mode requires either an S3 URI or an uploaded file')
         }
       } else {
         if (

apps/sim/tools/textract/types.ts

@@ -70,17 +70,14 @@ export interface TextractBlock {
   }
 }
 
-/** AWS Textract DocumentMetadata - exact API format */
 export interface TextractDocumentMetadataRaw {
   Pages: number
 }
 
-/** Normalized DocumentMetadata (camelCase) */
 export interface TextractDocumentMetadata {
   pages: number
 }
 
-/** AWS Textract API Response - exact API format */
 export interface TextractApiResponse {
   Blocks: TextractBlock[]
   DocumentMetadata: TextractDocumentMetadataRaw
@@ -94,7 +91,6 @@ export interface TextractNormalizedOutput {
   modelVersion?: string
 }
 
-/** Async job status response from Textract */
 export interface TextractAsyncJobResponse {
   JobStatus: 'IN_PROGRESS' | 'SUCCEEDED' | 'FAILED' | 'PARTIAL_SUCCESS'
   StatusMessage?: string