@twick/cloud-export-video 0.14.10 → 0.14.11

package/bin/twick-export-video.js

@@ -77,7 +77,9 @@ Examples:
     const image = rest[0];
     const dir = rest[1] || 'twick-export-video-aws';
     if (!image) throw new Error('Image name required. e.g., my-repo:latest');
-    await run('docker', ['build', '-t', image, dir]);
+    // Build for linux/amd64 platform to avoid creating multi-arch manifest index
+    // This reduces the number of artifacts pushed to the registry
+    await run('docker', ['build', '--platform', 'linux/amd64', '-t', image, dir]);
     return;
   }
 

package/core/renderer.js

@@ -37,8 +37,8 @@ const renderTwickVideo = async (variables, settings) => {
           name: "@twick/core/wasm",
         },
         size: {
-          x: variables.properties.width,
-          y: variables.properties.height,
+          x: variables.input.properties.width,
+          y: variables.input.properties.height,
         },
       },
       puppeteer: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@twick/cloud-export-video",
-  "version": "0.14.10",
+  "version": "0.14.11",
   "description": "Twick cloud function for exporting video with platform-specific templates (AWS Lambda container)",
   "type": "module",
   "main": "core/renderer.js",
@@ -43,13 +43,14 @@
   },
   "dependencies": {
     "@sparticuz/chromium": "^129.0.0",
-    "@twick/2d": "0.14.10",
-    "@twick/core": "0.14.10",
-    "@twick/ffmpeg": "0.14.10",
-    "@twick/renderer": "0.14.10",
-    "@twick/ui": "0.14.10",
-    "@twick/vite-plugin": "0.14.10",
-    "@twick/visualizer": "0.14.10",
+    "@twick/2d": "0.14.11",
+    "@twick/core": "0.14.11",
+    "@twick/ffmpeg": "0.14.11",
+    "@twick/renderer": "0.14.11",
+    "@twick/ui": "0.14.11",
+    "@twick/vite-plugin": "0.14.11",
+    "@twick/visualizer": "0.14.11",
+    "@aws-sdk/client-s3": "^3.620.0",
     "ffmpeg-static": "^5.2.0",
     "fluent-ffmpeg": "^2.1.3"
   },

package/platform/aws/Dockerfile

@@ -1,10 +1,21 @@
 FROM docker.io/revideo/aws-lambda-base-image:latest
 
+ARG TWICK_DIST_TAG=latest
+
 # Copy package files for better caching
 COPY package.json package-lock.json* ./
 
 RUN npm install
 
+RUN npm install --no-save \
+    "@twick/2d@${TWICK_DIST_TAG}" \
+    "@twick/core@${TWICK_DIST_TAG}" \
+    "@twick/ffmpeg@${TWICK_DIST_TAG}" \
+    "@twick/renderer@${TWICK_DIST_TAG}" \
+    "@twick/ui@${TWICK_DIST_TAG}" \
+    "@twick/vite-plugin@${TWICK_DIST_TAG}" \
+    "@twick/visualizer@${TWICK_DIST_TAG}"
+
 RUN npx puppeteer browsers install chrome
 
 # Copy source code

package/platform/aws/handler.js

@@ -1,8 +1,89 @@
+import { S3Client, PutObjectCommand } from '@aws-sdk/client-s3';
 import renderTwickVideo from '../../core/renderer.js';
 
+const s3Client = new S3Client({
+  region: process.env.EXPORT_VIDEO_S3_REGION || process.env.AWS_REGION || 'us-east-1',
+  endpoint: process.env.EXPORT_VIDEO_S3_ENDPOINT || undefined,
+  forcePathStyle: process.env.EXPORT_VIDEO_S3_FORCE_PATH_STYLE === 'true',
+});
+
+const ensureEnvVar = (name) => {
+  const value = process.env[name];
+  if (!value) {
+    throw new Error(`Missing required environment variable: ${name}`);
+  }
+  return value;
+};
+
+const normalizePrefix = (prefix = '') => {
+  if (!prefix) {
+    return '';
+  }
+  return prefix.endsWith('/') ? prefix : `${prefix}/`;
+};
+
+const sanitizeIdentifier = (value) => {
+  if (!value) {
+    return 'twick-video';
+  }
+
+  let sanitized = String(value)
+    .trim()
+    .toLowerCase()
+    .replace(/[^a-z0-9-_]+/g, '-')
+    .replace(/-{2,}/g, '-');
+  
+  // Remove leading and trailing dashes using string methods (avoids ReDoS)
+  // Find first non-dash character
+  let start = 0;
+  while (start < sanitized.length && sanitized[start] === '-') {
+    start++;
+  }
+  // Find last non-dash character
+  let end = sanitized.length;
+  while (end > start && sanitized[end - 1] === '-') {
+    end--;
+  }
+  
+  return sanitized.slice(start, end);
+};
+
+const buildObjectKey = (projectData, uniqueSuffix) => {
+  const projectIdentifier =
+    projectData?.properties?.id ??
+    projectData?.id ??
+    projectData?.project?.properties?.id;
+
+  const baseName = sanitizeIdentifier(projectIdentifier);
+  const suffix = uniqueSuffix ?? Date.now();
+
+  return `${baseName}-${suffix}.mp4`;
+};
+
+const encodeS3Key = (key) =>
+  key
+    .split('/')
+    .map((segment) => encodeURIComponent(segment))
+    .join('/');
+
+const buildPublicUrl = ({ bucket, key, region, baseUrl }) => {
+  if (baseUrl) {
+    const trimmedBase = baseUrl.endsWith('/') ? baseUrl.slice(0, -1) : baseUrl;
+    return `${trimmedBase}/${encodeS3Key(key)}`;
+  }
+
+  const encodedKey = encodeS3Key(key);
+
+  if (!region || region === 'us-east-1') {
+    return `https://${bucket}.s3.amazonaws.com/${encodedKey}`;
+  }
+
+  return `https://${bucket}.s3.${region}.amazonaws.com/${encodedKey}`;
+};
+
 /**
  * Handler for processing video project data with files
- * 
+ *
  * Expected JSON payload:
  * {
  *   "project": { ... }, // Video project JSON object
@@ -15,13 +96,21 @@ import renderTwickVideo from '../../core/renderer.js';
  *   ]
  * }
  * 
- * Returns: Processing result with video file
+ * Environment variables:
+ * - EXPORT_VIDEO_S3_BUCKET (required): Destination S3 bucket for rendered videos
+ * - EXPORT_VIDEO_S3_PREFIX (optional): Key prefix to prepend before the generated object key
+ * - EXPORT_VIDEO_S3_REGION (optional): Region for the S3 client (defaults to AWS_REGION or us-east-1)
+ * - EXPORT_VIDEO_PUBLIC_BASE_URL (optional): Custom base URL for returned video links
+ * - EXPORT_VIDEO_S3_ENDPOINT (optional): Custom endpoint for S3-compatible storage
+ * - EXPORT_VIDEO_S3_FORCE_PATH_STYLE (optional): Set to "true" to force path-style URLs
+ * 
+ * Returns: JSON payload containing the uploaded video URL and metadata
  */
 
 export const handler = async (event) => {
   console.log('Video processor function invoked');
   console.log('Event:', JSON.stringify(event));
-  const projectData = event.arguments?.input || {};
+  const projectData = event.arguments || {};
   
   try {
     // Validate required fields
@@ -56,37 +145,28 @@ export const handler = async (event) => {
     // Render the video using Twick renderer
     console.log('Starting video rendering...' );
     
+    const fs = await import('fs');
     let renderedVideoPath;
     let videoBuffer;
     
     try {
       // Render the video
       renderedVideoPath = await renderTwickVideo(projectData, {
-        outFile: `video-${projectData.properties?.id || Date.now()}.mp4`,
+        outFile: `video-${projectData.input?.properties?.requestId || `video-${Date.now()}`}.mp4`,
       });
 
       // Read the rendered video file
-      const fs = await import('fs');
       videoBuffer = fs.readFileSync(renderedVideoPath);
 
       console.log('Video rendered successfully:', renderedVideoPath);
       console.log('Video size:', videoBuffer.length, 'bytes');
-
-      // Clean up the temporary file
-      try {
-        fs.unlinkSync(renderedVideoPath);
-        console.log('Temporary video file cleaned up');
-      } catch (cleanupError) {
-        console.warn('Failed to clean up temporary file:', cleanupError);
-      }
-
     } catch (renderError) {
       console.error('Video rendering failed:', renderError);
       
       // Fallback to text file if rendering fails
       const errorText = `Video Processing Error
 ======================
-Request ID: ${projectData.properties?.id || 'N/A'}
+Request ID: ${projectData.input?.properties?.requestId || `video-${Date.now()}`}
 Timestamp: ${new Date().toISOString()}
 Status: Rendering Failed
 
@@ -107,19 +187,93 @@ ${mediaFiles.map((file, index) => `  ${index + 1}. ${file.filename} (${file.data
       };
     }
 
-    // Return the video file
+    const bucket = ensureEnvVar('EXPORT_VIDEO_S3_BUCKET');
+    const prefix = normalizePrefix(process.env.EXPORT_VIDEO_S3_PREFIX || '');
+    const region = process.env.EXPORT_VIDEO_S3_REGION || process.env.AWS_REGION || 'us-east-1';
+    const baseUrl = process.env.EXPORT_VIDEO_PUBLIC_BASE_URL;
+    const uniqueSuffix = Date.now();
+    const objectKey = `${prefix}${buildObjectKey(projectData, uniqueSuffix)}`;
+
+    console.log('Uploading rendered video to S3...', {
+      bucket,
+      key: objectKey,
+      region,
+      size: videoBuffer.length,
+      baseUrl: baseUrl ? '[redacted]' : undefined,
+    });
+
+    try {
+      await s3Client.send(
+        new PutObjectCommand({
+          Bucket: bucket,
+          Key: objectKey,
+          Body: videoBuffer,
+          ContentType: 'video/mp4',
+          ContentLength: videoBuffer.length,
+          Metadata: {
+            'project-id': String(
+              projectData?.input?.properties?.requestId ??
+                projectData?.input?.properties?.requestId ??
+                `video-${Date.now()}`
+            ),
+          },
+        })
+      );
+      console.log('Video uploaded to S3 successfully');
+    } catch (uploadError) {
+      console.error('Video upload failed:', uploadError);
+
+      try {
+        if (renderedVideoPath) {
+          fs.unlinkSync(renderedVideoPath);
+        }
+      } catch (cleanupError) {
+        console.warn('Failed to clean up temporary file after upload failure:', cleanupError);
+      }
+
+      return {
+        statusCode: 500,
+        headers: {
+          'Content-Type': 'application/json',
+          'Access-Control-Allow-Origin': '*',
+          'Access-Control-Allow-Headers': 'Content-Type',
+          'Access-Control-Allow-Methods': 'POST, OPTIONS',
+        },
+        body: JSON.stringify({
+          error: 'Failed to upload rendered video',
+          message: uploadError instanceof Error ? uploadError.message : 'Unknown error',
+        }),
+      };
+    }
+
+    try {
+      if (renderedVideoPath) {
+        fs.unlinkSync(renderedVideoPath);
+        console.log('Temporary video file cleaned up');
+      }
+    } catch (cleanupError) {
+      console.warn('Failed to clean up temporary file:', cleanupError);
+    }
+
+    const videoUrl = buildPublicUrl({ bucket, key: objectKey, region, baseUrl });
+    console.log('Video available at URL:', videoUrl);
+
+    // Return the video file metadata with URL
     return {
       statusCode: 200,
       headers: {
-        'Content-Type': 'video/mp4',
-        'Content-Disposition': `attachment; filename="processed-video.mp4"`,
-        'Content-Length': videoBuffer.length,
+        'Content-Type': 'application/json',
         'Access-Control-Allow-Origin': '*',
         'Access-Control-Allow-Headers': 'Content-Type',
         'Access-Control-Allow-Methods': 'POST, OPTIONS',
       },
-      body: videoBuffer.toString('base64'),
-      isBase64Encoded: true,
+      body: JSON.stringify({
+        url: videoUrl,
+        bucket,
+        key: objectKey,
+        size: videoBuffer.length,
+        contentType: 'video/mp4',
+      }),
     };
   } catch (error) {
     console.error('Error processing video project:', error);