@llumiverse/drivers 1.3.0 → 1.4.0

package/src/bedrock/nova-image-payload.ts

@@ -1,46 +1,41 @@
-import { ExecutionOptions, NovaCanvasOptions } from "@llumiverse/core";
-import { NovaMessage, NovaMessagesPrompt } from "@llumiverse/core/formatters";
+import type { ExecutionOptions, NovaCanvasOptions } from '@llumiverse/core';
+import type { NovaMessage, NovaMessagesPrompt } from '@llumiverse/core/formatters';
 
 function getFirstImageFromPrompt(prompt: NovaMessage[]) {
-
-    const msgImage = prompt.find(m => m.content.find(c => c.image));
+    const msgImage = prompt.find((m) => m.content.find((c) => c.image));
     if (!msgImage) {
         return undefined;
     }
 
-    return msgImage.content.find(c => c.image)?.image;
+    return msgImage.content.find((c) => c.image)?.image;
 }
 
-//@ts-ignore
-function getAllImagesFromPrompt(prompt: NovaMessage[]) {
-
-    const contentMsg = prompt.filter(m => m.content).map(m => m.content).flat();
-    const imgParts = contentMsg.filter(c => c.image);
-    if (!imgParts?.length) {
-        return undefined;
-    }
-
-    const images = imgParts.map(i => i.image).filter(i => i?.source?.bytes).map(i => i!.source.bytes);
-    return images;
+function getAllImagesFromPrompt(prompt: NovaMessage[]): string[] | undefined {
+    const contentMsg = prompt.filter((m) => m.content).flatMap((m) => m.content);
+    const images = contentMsg.map((c) => c.image?.source?.bytes).filter((b): b is string => b !== undefined);
+    return images.length > 0 ? images : undefined;
 }
 
-async function textToImagePayload(prompt: NovaMessagesPrompt, options: ExecutionOptions): Promise<NovaTextToImagePayload> {
+async function textToImagePayload(
+    prompt: NovaMessagesPrompt,
+    options: ExecutionOptions,
+): Promise<NovaTextToImagePayload> {
     const modelOptions = options.model_options as NovaCanvasOptions;
 
-    const textMessages = prompt.messages.map(m => m.content.map(c => c.text)).flat();
-    let text = textMessages.join("\n\n");
-    text += prompt.system ? "\n\n\nIMPORTANT: " + prompt.system?.map(m => m.text).join("\n\n") : '';
+    const textMessages = prompt.messages.flatMap((m) => m.content.map((c) => c.text));
+    let text = textMessages.join('\n\n');
+    text += prompt.system ? `\n\n\nIMPORTANT: ${prompt.system?.map((m) => m.text).join('\n\n')}` : '';
 
     const conditionImage = (conditionImage: boolean) => {
         const img = getFirstImageFromPrompt(prompt.messages);
         if (img && conditionImage) {
-            return img
+            return img;
         }
         return undefined;
-    }
+    };
 
     const payload: NovaTextToImagePayload = {
-        taskType: NovaImageGenerationTaskType.TEXT_IMAGE,   // Always TEXT_IMAGE, as TEXT_IMAGE_WITH_IMAGE_CONDITIONING is only an internal marker.
+        taskType: NovaImageGenerationTaskType.TEXT_IMAGE, // Always TEXT_IMAGE, as TEXT_IMAGE_WITH_IMAGE_CONDITIONING is only an internal marker.
         imageGenerationConfig: {
             quality: modelOptions?.quality,
             width: modelOptions.width,
@@ -51,20 +46,23 @@ async function textToImagePayload(prompt: NovaMessagesPrompt, options: Execution
         },
         textToImageParams: {
             text: text,
-            conditionImage: conditionImage(modelOptions?.controlMode ? true : false)?.source.bytes,
+            conditionImage: conditionImage(!!modelOptions?.controlMode)?.source.bytes,
             controlMode: modelOptions?.controlMode,
             controlStrength: modelOptions?.controlStrength,
-            negativeText: prompt.negative
-        }
-    }
+            negativeText: prompt.negative,
+        },
+    };
 
     return payload;
 }
 
-async function imageVariationPayload(prompt: NovaMessagesPrompt, options: ExecutionOptions): Promise<NovaImageVariationPayload> {
+async function imageVariationPayload(
+    prompt: NovaMessagesPrompt,
+    options: ExecutionOptions,
+): Promise<NovaImageVariationPayload> {
     const modelOptions = options.model_options as NovaCanvasOptions;
 
-    const text = prompt.messages.map(m => m.content).join("\n\n");
+    const text = prompt.messages.map((m) => m.content).join('\n\n');
     const images = getAllImagesFromPrompt(prompt.messages);
 
     const payload: NovaImageVariationPayload = {
@@ -82,26 +80,29 @@ async function imageVariationPayload(prompt: NovaMessagesPrompt, options: Execut
             text: text,
             negativeText: prompt.negative,
             similarityStrength: modelOptions?.similarityStrength,
-        }
-    }
+        },
+    };
 
     return payload;
 }
 
-async function colorGuidedGenerationPayload(prompt: NovaMessagesPrompt, options: ExecutionOptions): Promise<NovaColorGuidedGenerationPayload> {
+async function colorGuidedGenerationPayload(
+    prompt: NovaMessagesPrompt,
+    options: ExecutionOptions,
+): Promise<NovaColorGuidedGenerationPayload> {
     const modelOptions = options.model_options as NovaCanvasOptions;
 
-    const textMessages = prompt.messages.map(m => m.content.map(c => c.text)).flat();
-    let text = textMessages.join("\n\n");
-    text += prompt.system ? "\n\n\nIMPORTANT: " + prompt.system?.map(m => m.text).join("\n\n") : '';
+    const textMessages = prompt.messages.flatMap((m) => m.content.map((c) => c.text));
+    let text = textMessages.join('\n\n');
+    text += prompt.system ? `\n\n\nIMPORTANT: ${prompt.system?.map((m) => m.text).join('\n\n')}` : '';
 
     const conditionImage = (conditionImage: boolean) => {
         const img = getFirstImageFromPrompt(prompt.messages);
         if (img && conditionImage) {
-            return img
+            return img;
         }
         return undefined;
-    }
+    };
 
     const payload: NovaColorGuidedGenerationPayload = {
         taskType: NovaImageGenerationTaskType.COLOR_GUIDED_GENERATION,
@@ -116,38 +117,40 @@ async function colorGuidedGenerationPayload(prompt: NovaMessagesPrompt, options:
         colorGuidedGenerationParams: {
             colors: modelOptions.colors ?? [],
             text: text,
-            referenceImage: conditionImage(modelOptions?.controlMode ? true : false)?.source.bytes,
-            negativeText: prompt.negative
-        }
-    }
+            referenceImage: conditionImage(!!modelOptions?.controlMode)?.source.bytes,
+            negativeText: prompt.negative,
+        },
+    };
 
     return payload;
 }
 
 async function backgroundRemovalPayload(prompt: NovaMessagesPrompt): Promise<NovaBackgroundRemovalPayload> {
-
     const image = getFirstImageFromPrompt(prompt.messages);
     if (!image?.source.bytes) {
-        throw new Error("No image found in prompt");
+        throw new Error('No image found in prompt');
     }
 
     const payload: NovaBackgroundRemovalPayload = {
         taskType: NovaImageGenerationTaskType.BACKGROUND_REMOVAL,
         backgroundRemovalParams: {
-            image: image.source.bytes
-        }
-    }
-    console.log(payload)
+            image: image.source.bytes,
+        },
+    };
+    console.log(payload);
 
     return payload;
 }
 
-async function inpaintingPayload(prompt: NovaMessagesPrompt, options: ExecutionOptions): Promise<NovaInpaintingPayload> {
+async function inpaintingPayload(
+    prompt: NovaMessagesPrompt,
+    options: ExecutionOptions,
+): Promise<NovaInpaintingPayload> {
     const modelOptions = options.model_options as NovaCanvasOptions;
 
     const images = getAllImagesFromPrompt(prompt.messages);
     if (!images?.length || images.length < 2) {
-        throw new Error("2 images are required for inpainting");
+        throw new Error('2 images are required for inpainting');
     }
     const sourceImage = images[0];
     const maskImage = images[1];
@@ -165,20 +168,23 @@ async function inpaintingPayload(prompt: NovaMessagesPrompt, options: ExecutionO
         inPaintingParams: {
             image: sourceImage,
             maskImage: maskImage,
-            text: prompt.messages.map(m => m.content.map(c => c.text)).flat().join("\n\n"),
-            negativeText: prompt.negative
-        }
-    }
+            text: prompt.messages.flatMap((m) => m.content.map((c) => c.text)).join('\n\n'),
+            negativeText: prompt.negative,
+        },
+    };
 
     return payload;
 }
 
-async function outpaintingPayload(prompt: NovaMessagesPrompt, options: ExecutionOptions): Promise<NovaOutpaintingPayload> {
+async function outpaintingPayload(
+    prompt: NovaMessagesPrompt,
+    options: ExecutionOptions,
+): Promise<NovaOutpaintingPayload> {
     const modelOptions = options.model_options as NovaCanvasOptions;
 
     const images = getAllImagesFromPrompt(prompt.messages);
     if (!images?.length || images.length < 2) {
-        throw new Error("2 images are required for outpainting");
+        throw new Error('2 images are required for outpainting');
     }
     const sourceImage = images[0];
     const maskImage = images[1];
@@ -196,17 +202,20 @@ async function outpaintingPayload(prompt: NovaMessagesPrompt, options: Execution
         outPaintingParams: {
             image: sourceImage,
             maskImage: maskImage,
-            text: prompt.messages.map(m => m.content.map(c => c.text)).flat().join("\n\n"),
+            text: prompt.messages.flatMap((m) => m.content.map((c) => c.text)).join('\n\n'),
             negativeText: prompt.negative,
-            outPaintingMode: modelOptions?.outPaintingMode ?? "DEFAULT"
-        }
-    }
+            outPaintingMode: modelOptions?.outPaintingMode ?? 'DEFAULT',
+        },
+    };
 
     return payload;
 }
 
-export function formatNovaImageGenerationPayload(taskType: string, prompt: NovaMessagesPrompt, options: ExecutionOptions) {
-
+export function formatNovaImageGenerationPayload(
+    taskType: string,
+    prompt: NovaMessagesPrompt,
+    options: ExecutionOptions,
+) {
     switch (taskType) {
         case NovaImageGenerationTaskType.TEXT_IMAGE:
             return textToImagePayload(prompt, options);
@@ -223,9 +232,8 @@ export function formatNovaImageGenerationPayload(taskType: string, prompt: NovaM
         case NovaImageGenerationTaskType.BACKGROUND_REMOVAL:
             return backgroundRemovalPayload(prompt);
         default:
-            throw new Error("Task type not supported");
+            throw new Error('Task type not supported');
     }
-
 }
 
 export interface InvokeModelPayloadBase {
@@ -233,7 +241,7 @@ export interface InvokeModelPayloadBase {
     imageGenerationConfig: {
         width?: number;
         height?: number;
-        quality?: "standard" | "premium";
+        quality?: 'standard' | 'premium';
         cfgScale?: number;
         seed?: number;
         numberOfImages?: number;
@@ -243,21 +251,20 @@ export interface InvokeModelPayloadBase {
 export interface NovaTextToImagePayload extends InvokeModelPayloadBase {
     textToImageParams: {
         conditionImage?: string;
-        controlMode?: "CANNY_EDGE" | "SEGMENTATION";
+        controlMode?: 'CANNY_EDGE' | 'SEGMENTATION';
         controlStrength?: number;
         text: string;
         negativeText?: string;
     };
 }
 
-
 export interface NovaImageVariationPayload extends InvokeModelPayloadBase {
     imageVariationParams: {
-        images: string[]  //(list of Base64 encoded images),
-        similarityStrength?: number,
-        text?: string,
-        negativeText?: string
-    }
+        images: string[]; //(list of Base64 encoded images),
+        similarityStrength?: number;
+        text?: string;
+        negativeText?: string;
+    };
 }
 
 export interface NovaColorGuidedGenerationPayload extends InvokeModelPayloadBase {
@@ -266,43 +273,43 @@ export interface NovaColorGuidedGenerationPayload extends InvokeModelPayloadBase
         text: string;
         referenceImage?: string;
         negativeText?: string;
-    }
+    };
 }
 
 export interface NovaInpaintingPayload extends InvokeModelPayloadBase {
     inPaintingParams: {
         image: string; //(Base64 encoded image),
         maskImage?: string; //(Base64 encoded image),
-        maskPrompt?: string,
-        negativeText?: string,
-        text?: string,
-    }
+        maskPrompt?: string;
+        negativeText?: string;
+        text?: string;
+    };
 }
 
 export interface NovaOutpaintingPayload extends InvokeModelPayloadBase {
     outPaintingParams: {
         image: string; //(Base64 encoded image),
         maskImage?: string; //(Base64 encoded image),
-        maskPrompt?: string,
-        negativeText?: string,
-        text?: string,
-        outPaintingMode: "DEFAULT" | "PRECISE";
-    }
+        maskPrompt?: string;
+        negativeText?: string;
+        text?: string;
+        outPaintingMode: 'DEFAULT' | 'PRECISE';
+    };
 }
 
 export interface NovaBackgroundRemovalPayload {
     taskType: NovaImageGenerationTaskType.BACKGROUND_REMOVAL;
     backgroundRemovalParams: {
-        image: string //(Base64 encoded image),
-    }
+        image: string; //(Base64 encoded image),
+    };
 }
 
 export enum NovaImageGenerationTaskType {
-    TEXT_IMAGE = "TEXT_IMAGE",
-    TEXT_IMAGE_WITH_IMAGE_CONDITIONING = "TEXT_IMAGE_WITH_IMAGE_CONDITIONING",
-    COLOR_GUIDED_GENERATION = "COLOR_GUIDED_GENERATION",
-    IMAGE_VARIATION = "IMAGE_VARIATION",
-    INPAINTING = "INPAINTING",
-    OUTPAINTING = "OUTPAINTING",
-    BACKGROUND_REMOVAL = "BACKGROUND_REMOVAL",
-}
+    TEXT_IMAGE = 'TEXT_IMAGE',
+    TEXT_IMAGE_WITH_IMAGE_CONDITIONING = 'TEXT_IMAGE_WITH_IMAGE_CONDITIONING',
+    COLOR_GUIDED_GENERATION = 'COLOR_GUIDED_GENERATION',
+    IMAGE_VARIATION = 'IMAGE_VARIATION',
+    INPAINTING = 'INPAINTING',
+    OUTPAINTING = 'OUTPAINTING',
+    BACKGROUND_REMOVAL = 'BACKGROUND_REMOVAL',
+}

package/src/bedrock/payloads.ts

@@ -1,13 +1,13 @@
-import { NovaMessagesPrompt } from "@llumiverse/core/formatters";
+import type { NovaMessagesPrompt } from '@llumiverse/core/formatters';
 
 //Docs at: https://docs.aws.amazon.com/nova/latest/userguide/complete-request-schema.html
 export interface NovaPayload extends NovaMessagesPrompt {
-    schemaVersion: string,
+    schemaVersion: string;
     inferenceConfig?: {
-        max_new_tokens?: number,
-        temperature?: number,
-        top_p?: number,
-        top_k?: number,
-        stopSequences?: [string]
-    }
-}
+        max_new_tokens?: number;
+        temperature?: number;
+        top_p?: number;
+        top_k?: number;
+        stopSequences?: [string];
+    };
+}

package/src/bedrock/s3.test.ts

@@ -0,0 +1,39 @@
+import { describe, expect, it } from 'vitest';
+import { isAmazonS3Hostname, parseS3UrlToUri } from './s3.js';
+
+describe('isAmazonS3Hostname', () => {
+    it('accepts supported Amazon S3 hostnames', () => {
+        expect(isAmazonS3Hostname('s3.amazonaws.com')).toBe(true);
+        expect(isAmazonS3Hostname('s3.us-east-1.amazonaws.com')).toBe(true);
+        expect(isAmazonS3Hostname('s3.dualstack.us-east-1.amazonaws.com')).toBe(true);
+        expect(isAmazonS3Hostname('my-bucket.s3.amazonaws.com')).toBe(true);
+        expect(isAmazonS3Hostname('my-bucket.s3.us-east-1.amazonaws.com')).toBe(true);
+        expect(isAmazonS3Hostname('my-bucket.s3.dualstack.us-east-1.amazonaws.com')).toBe(true);
+    });
+
+    it('rejects hostnames that only contain amazonaws.com as a substring', () => {
+        expect(isAmazonS3Hostname('s3.amazonaws.com.example.com')).toBe(false);
+        expect(isAmazonS3Hostname('example-s3.amazonaws.com')).toBe(false);
+        expect(isAmazonS3Hostname('bucket.s3.amazonaws.com.evil.test')).toBe(false);
+    });
+});
+
+describe('parseS3UrlToUri', () => {
+    it('converts virtual-hosted style S3 URLs', () => {
+        expect(parseS3UrlToUri(new URL('https://my-bucket.s3.us-east-1.amazonaws.com/folder/video.mp4'))).toBe(
+            's3://my-bucket/folder/video.mp4',
+        );
+    });
+
+    it('converts path-style S3 URLs', () => {
+        expect(parseS3UrlToUri(new URL('https://s3.us-east-1.amazonaws.com/my-bucket/folder/video.mp4'))).toBe(
+            's3://my-bucket/folder/video.mp4',
+        );
+    });
+
+    it('rejects spoofed S3-looking URLs', () => {
+        expect(() => parseS3UrlToUri(new URL('https://bucket.s3.amazonaws.com.evil.test/video.mp4'))).toThrow(
+            'Unable to determine bucket name from URL',
+        );
+    });
+});

package/src/bedrock/s3.ts

@@ -1,12 +1,18 @@
-import { CreateBucketCommand, HeadBucketCommand, S3Client } from "@aws-sdk/client-s3";
-import { Progress, Upload } from "@aws-sdk/lib-storage";
+import { CreateBucketCommand, HeadBucketCommand, type S3Client } from '@aws-sdk/client-s3';
+import { type Progress, Upload } from '@aws-sdk/lib-storage';
+
+const S3_AMAZONAWS_HOSTNAME_RE = /^(?:s3(?:\.[a-z0-9-]+)*|.+\.s3(?:\.[a-z0-9-]+)*)\.amazonaws\.com$/;
+
+export function isAmazonS3Hostname(hostname: string): boolean {
+    return S3_AMAZONAWS_HOSTNAME_RE.test(hostname.toLowerCase());
+}
 
 export async function doesBucketExist(s3: S3Client, bucketName: string): Promise<boolean> {
     try {
         await s3.send(new HeadBucketCommand({ Bucket: bucketName }));
         return true;
-    } catch (err: any) {
-        if (err.name === 'NotFound') {
+    } catch (err: unknown) {
+        if (err && typeof err === 'object' && (err as { name?: unknown }).name === 'NotFound') {
             return false;
         }
         throw err;
@@ -14,12 +20,13 @@ export async function doesBucketExist(s3: S3Client, bucketName: string): Promise
 }
 
 export function createBucket(s3: S3Client, bucketName: string) {
-    return s3.send(new CreateBucketCommand({
-        Bucket: bucketName
-    }));
+    return s3.send(
+        new CreateBucketCommand({
+            Bucket: bucketName,
+        }),
+    );
 }
 
-
 export async function tryCreateBucket(s3: S3Client, bucketName: string) {
     const exists = await doesBucketExist(s3, bucketName);
     if (!exists) {
@@ -27,19 +34,23 @@ export async function tryCreateBucket(s3: S3Client, bucketName: string) {
     }
 }
 
-
-export async function uploadFile(s3: S3Client, source: ReadableStream, bucketName: string, file: string, onProgress?: (progress: Progress) => void) {
-
+export async function uploadFile(
+    s3: S3Client,
+    source: ReadableStream,
+    bucketName: string,
+    file: string,
+    onProgress?: (progress: Progress) => void,
+) {
     const upload = new Upload({
         client: s3,
         params: {
             Bucket: bucketName,
             Key: file,
             Body: source,
-        }
+        },
     });
 
-    onProgress && upload.on("httpUploadProgress", onProgress);
+    if (onProgress) upload.on('httpUploadProgress', onProgress);
 
     const result = await upload.done();
     return result;
@@ -47,20 +58,25 @@ export async function uploadFile(s3: S3Client, source: ReadableStream, bucketNam
 
 /**
  * Create the bucket if not already exists and then upload the file.
- * @param s3 
- * @param source 
- * @param bucketName 
- * @param file 
- * @param onProgress 
- * @returns 
+ * @param s3
+ * @param source
+ * @param bucketName
+ * @param file
+ * @param onProgress
+ * @returns
  */
-export async function forceUploadFile(s3: S3Client, source: ReadableStream, bucketName: string, file: string, onProgress?: (progress: Progress) => void) {
+export async function forceUploadFile(
+    s3: S3Client,
+    source: ReadableStream,
+    bucketName: string,
+    file: string,
+    onProgress?: (progress: Progress) => void,
+) {
     // make sure the bucket exists
     await tryCreateBucket(s3, bucketName);
     return uploadFile(s3, source, bucketName, file, onProgress);
 }
 
-
 /**
  * Parse an S3 HTTPS URL into an S3 URI format
  * s3Url - The S3 HTTPS URL (e.g., https://bucket.s3.region.amazonaws.com/key)
@@ -71,25 +87,28 @@ export function parseS3UrlToUri(s3Url: URL) {
         const url = new URL(s3Url);
 
         // Extract the hostname which contains the bucket and S3 endpoint
-        const hostname = url.hostname;
+        const hostname = url.hostname.toLowerCase();
+
+        if (!isAmazonS3Hostname(hostname)) {
+            throw new Error('Unable to determine bucket name from URL');
+        }
 
         // Parse the hostname to extract the bucket name
-        let bucketName;
-        if (hostname.endsWith('.amazonaws.com')) {
-            if (hostname.includes('.s3.')) {
-                // Format: bucket-name.s3.region.amazonaws.com
-                bucketName = hostname.split('.s3.')[0];
-            } else if (hostname.startsWith('s3.')) {
-                // Format: s3.region.amazonaws.com/bucket-name
-                // In this case, the bucket is actually in the first segment of the pathname
-                bucketName = url.pathname.split('/')[1];
-                // Adjust the pathname to remove the bucket name
-                const pathParts = url.pathname.split('/').slice(2);
-                url.pathname = '/' + pathParts.join('/');
-            } else {
-                throw new Error('Unable to determine bucket name from URL');
-            }
+        let bucketName: string | undefined;
+        const virtualHostedMatch = hostname.match(/^(.+)\.s3(?:\.[a-z0-9-]+)*\.amazonaws\.com$/);
+        if (virtualHostedMatch) {
+            // Format: bucket-name.s3.region.amazonaws.com
+            bucketName = virtualHostedMatch[1];
         } else {
+            // Format: s3.region.amazonaws.com/bucket-name
+            // In this case, the bucket is actually in the first segment of the pathname
+            bucketName = url.pathname.split('/')[1];
+            // Adjust the pathname to remove the bucket name
+            const pathParts = url.pathname.split('/').slice(2);
+            url.pathname = `/${pathParts.join('/')}`;
+        }
+
+        if (!bucketName) {
             throw new Error('Unable to determine bucket name from URL');
         }
 
@@ -106,4 +125,4 @@ export function parseS3UrlToUri(s3Url: URL) {
         console.error('Error parsing S3 URL:', error);
         throw error;
     }
-}
+}