@zodic/shared 0.0.358 → 0.0.359

package/app/services/ArtifactService.ts

@@ -0,0 +1,631 @@
+import { and, eq } from 'drizzle-orm';
+import { inject, injectable } from 'inversify';
+import { v4 } from 'uuid';
+import { ImageDescriberService } from './ImageDescriberService';
+import { AppContext } from '../base';
+import { LeonardoService } from './LeonardoService';
+import { ArtifactList, schema } from '../..';
+import { sizes } from '../../types/scopes/legacy';
+import { users } from '../../db/schema';
+
+@injectable()
+export class ArtifactService {
+  constructor(
+    @inject(AppContext) private context: AppContext,
+    @inject(LeonardoService) private leonardoService: LeonardoService,
+    @inject(ImageDescriberService)
+    private imageDescriberService: ImageDescriberService
+  ) {}
+
+  private async log(
+    level: 'info' | 'debug' | 'warn' | 'error',
+    message: string,
+    context: Record<string, any> = {}
+  ) {
+    const logId = `artifact-service:${Date.now()}`;
+    const logMessage = `[${level.toUpperCase()}] ${message}`;
+
+    console[level](logMessage, context);
+    const db = this.context.drizzle();
+    try {
+      await db
+        .insert(schema.logs)
+        .values({
+          id: logId,
+          level,
+          message,
+          context: JSON.stringify(context),
+          createdAt: new Date().getTime(),
+        })
+        .execute();
+    } catch (error) {
+      console.error('[ERROR] Failed to persist log to database:', {
+        error,
+        logId,
+        message,
+        rawContext: context,
+        stringifiedContext: JSON.stringify(context),
+        createdAt: new Date().getTime(),
+      });
+    }
+  }
+
+  async generateCosmicMirror(
+    artifactId: string,
+    userId: string,
+    generatedImageId: string,
+    archetypeDataId: string
+  ) {
+    const { height, width } = sizes['alchemy']['post4:5'];
+
+    await this.log('info', 'Starting cosmic mirror generation', {
+      artifactId,
+      userId,
+      generatedImageId,
+      archetypeDataId,
+    });
+
+    const drizzle = this.context.drizzle();
+    const {
+      artifacts,
+      userArtifacts,
+      generations,
+      userConcepts,
+      cosmicMirrorImages,
+    } = schema;
+
+    try {
+      // Fetch the artifact and its linked conceptId first
+      const [artifact] = await drizzle
+        .select({
+          id: artifacts.id,
+          conceptId: artifacts.conceptId,
+        })
+        .from(artifacts)
+        .where(eq(artifacts.slug, ArtifactList.COSMIC_MIRROR))
+        .limit(1);
+
+      if (!artifact || !artifact.id || !artifact.conceptId) {
+        return {
+          status: 'error',
+          error: 'Artifact or linked concept not found. Check registration.',
+          statusCode: 500,
+        };
+      }
+
+      // Check for existing cosmic mirror artifact
+      const [existingArtifact] = await drizzle
+        .select()
+        .from(userArtifacts)
+        .where(
+          and(
+            eq(userArtifacts.userId, userId),
+            eq(userArtifacts.artifactId, artifact.id)
+          )
+        )
+        .limit(1);
+
+      if (existingArtifact) {
+        const artifactAge =
+          Date.now() - new Date(existingArtifact.createdAt).getTime();
+        const twentyMinutesMs = 20 * 60 * 1000;
+
+        if (
+          existingArtifact.status === 'pending' &&
+          artifactAge < twentyMinutesMs
+        ) {
+          return {
+            status: 'error',
+            error:
+              'You already have a cosmic mirror being generated. Please wait for it to complete.',
+            statusCode: 400,
+          };
+        }
+
+        // Check D1 for existing images
+        const existingImages = await drizzle
+          .select()
+          .from(cosmicMirrorImages)
+          .where(eq(cosmicMirrorImages.userArtifactId, existingArtifact.id));
+
+        if (existingImages.length >= 6 && artifactAge >= twentyMinutesMs) {
+          // If we have 6 images and artifact is old, trigger faceswaps
+          return await this.retryStaleCosmicMirror(existingArtifact.id);
+        }
+
+        // Clean up old artifact if incomplete
+        if (artifactAge >= twentyMinutesMs) {
+          await this.cleanupStaleCosmicMirror(existingArtifact.id);
+        } else {
+          return {
+            status: 'error',
+            error: 'You can only have one cosmic mirror artifact at this time.',
+            statusCode: 400,
+          };
+        }
+      }
+
+      // Fetch user information
+      const [user] = await drizzle
+        .select({
+          userPhotoId: users.userPhotoId,
+          userPhotoUrl: users.userPhotoUrl,
+          userGender: users.gender,
+          profileImage: users.profileImage,
+        })
+        .from(users)
+        .where(eq(users.id, userId))
+        .limit(1);
+
+      if (!user) {
+        return {
+          status: 'error',
+          error: 'User not found',
+          statusCode: 400,
+        };
+      }
+
+      let userPhotoId = user.userPhotoId;
+      let userPhotoUrl = user.userPhotoUrl;
+
+      // Upload profileImage to Leonardo if userPhotoId or userPhotoUrl is missing
+      if (!userPhotoId || !userPhotoUrl) {
+        if (!user.profileImage) {
+          return {
+            status: 'error',
+            error:
+              'User profile image not found. Please upload an image first.',
+            statusCode: 400,
+          };
+        }
+
+        console.info(
+          `Uploading user profile image to Leonardo: ${user.profileImage}`
+        );
+
+        const uploadResponse = await this.leonardoService.uploadImageByUrl(
+          user.profileImage
+        );
+
+        if (!uploadResponse) {
+          return {
+            status: 'error',
+            error: 'Failed to upload user profile image to Leonardo',
+            statusCode: 500,
+          };
+        }
+
+        userPhotoId = uploadResponse.uploadedImageId;
+        userPhotoUrl = uploadResponse.uploadedImageUrl;
+
+        console.info('User profile image uploaded to Leonardo:', {
+          userPhotoId,
+          userPhotoUrl,
+        });
+
+        // Update user record with new photo data
+        await drizzle
+          .update(users)
+          .set({
+            userPhotoId,
+            userPhotoUrl,
+            updatedAt: new Date(),
+          })
+          .where(eq(users.id, userId));
+      }
+
+      if (!user.userGender) {
+        return {
+          status: 'error',
+          error: 'User gender not found. Please define a gender first.',
+          statusCode: 400,
+        };
+      }
+
+      // Fetch the user's concept with combinationId
+      const [userConcept] = await drizzle
+        .select({
+          id: userConcepts.id,
+          conceptCombinationId: userConcepts.conceptCombinationId,
+        })
+        .from(userConcepts)
+        .where(
+          and(
+            eq(userConcepts.userId, userId),
+            eq(userConcepts.conceptId, artifact.conceptId)
+          )
+        )
+        .limit(1);
+
+      if (!userConcept) {
+        return {
+          status: 'error',
+          error: 'User concept not found. Please generate the concept first.',
+          statusCode: 400,
+        };
+      }
+
+      // Get the archetype data record
+      const [archetypeData] = await drizzle
+        .select({
+          id: schema.archetypesData.id,
+          leonardoPrompt: schema.archetypesData.leonardoPrompt,
+        })
+        .from(schema.archetypesData)
+        .where(eq(schema.archetypesData.id, archetypeDataId))
+        .limit(1);
+
+      if (!archetypeData) {
+        return {
+          status: 'error',
+          error: 'Archetype data not found for this combination and gender.',
+          statusCode: 404,
+        };
+      }
+
+      if (!archetypeData.leonardoPrompt) {
+        return {
+          status: 'error',
+          error: `Archetype data is incomplete. Leonardo Prompt not found for ArchetypeDataId: ${archetypeData}`,
+          statusCode: 404,
+        };
+      }
+
+      // Create the user artifact with new schema
+      const userArtifactId = v4();
+      await drizzle.insert(userArtifacts).values({
+        id: userArtifactId,
+        userId,
+        artifactId: artifact.id,
+        userConceptId: userConcept.id,
+        conceptId: artifact.conceptId,
+        archetypeDataId: archetypeData.id,
+        postImages: '[]',
+        status: 'pending',
+        createdAt: new Date(),
+      });
+
+      // Describe the user photo
+      const traits = await this.imageDescriberService.describeImage({
+        imageUrl: userPhotoUrl,
+      });
+
+      // Personalize the Leonardo prompt
+      const personalizedPrompt =
+        await this.leonardoService.personalizeCosmicMirrorLeonardoPrompt({
+          leonardoPrompt: archetypeData.leonardoPrompt,
+          traits,
+        });
+
+      // First generation - with both control nets (content + character)
+      const generationResponse1 = await this.context
+        .api()
+        .callLeonardo.generateImage({
+          prompt: personalizedPrompt,
+          width,
+          height,
+          quantity: 3,
+          controlNets: [
+            {
+              initImageId: userPhotoId,
+              initImageType: 'UPLOADED',
+              preprocessorId: 133, // Character Reference
+              strengthType: 'High',
+            },
+            {
+              initImageId: generatedImageId,
+              initImageType: 'GENERATED',
+              preprocessorId: 100, // Content Reference
+              strengthType: 'Low',
+            },
+          ],
+        });
+
+      if (
+        !generationResponse1 ||
+        !generationResponse1.sdGenerationJob ||
+        !generationResponse1.sdGenerationJob.generationId
+      ) {
+        console.error('First Leonardo generation response is incorrect.');
+        return {
+          status: 'error',
+          error: 'First Leonardo generation failed.',
+          statusCode: 500,
+        };
+      }
+
+      const generationId1 = generationResponse1.sdGenerationJob.generationId;
+      await drizzle.insert(generations).values({
+        id: generationId1,
+        userId,
+        artifactId: artifact.id,
+        userArtifactId,
+        type: ArtifactList.COSMIC_MIRROR,
+        status: 'pending',
+        createdAt: new Date(),
+      });
+
+      // Second generation - with only character control net
+      const generationResponse2 = await this.context
+        .api()
+        .callLeonardo.generateImage({
+          prompt: personalizedPrompt,
+          width,
+          height,
+          quantity: 3,
+          controlNets: [
+            {
+              initImageId: userPhotoId,
+              initImageType: 'UPLOADED',
+              preprocessorId: 133, // Character Reference
+              strengthType: 'High',
+            },
+          ],
+        });
+
+      if (
+        !generationResponse2 ||
+        !generationResponse2.sdGenerationJob ||
+        !generationResponse2.sdGenerationJob.generationId
+      ) {
+        console.error('Second Leonardo generation response is incorrect.');
+        return {
+          status: 'error',
+          error: 'Second Leonardo generation failed.',
+          statusCode: 500,
+        };
+      }
+
+      const generationId2 = generationResponse2.sdGenerationJob.generationId;
+      await drizzle.insert(generations).values({
+        id: generationId2,
+        userId,
+        artifactId: artifact.id,
+        userArtifactId,
+        type: ArtifactList.COSMIC_MIRROR,
+        status: 'pending',
+        createdAt: new Date(),
+      });
+
+      return {
+        status: 'success',
+        data: {
+          generations: {
+            contentCharacter: generationResponse1,
+            characterOnly: generationResponse2,
+          },
+          userArtifactId,
+        },
+        statusCode: 200,
+      };
+    } catch (error) {
+      console.error('Error generating user artifact:', error);
+      return {
+        status: 'error',
+        error: 'Failed to generate user artifact',
+        statusCode: 500,
+      };
+    }
+  }
+
+  async cleanupStaleCosmicMirror(userArtifactId: string) {
+    const drizzle = this.context.drizzle();
+    const { cosmicMirrorImages, generations, userArtifacts } = schema;
+
+    // Delete images from cosmicMirrorImages
+    await drizzle
+      .delete(cosmicMirrorImages)
+      .where(eq(cosmicMirrorImages.userArtifactId, userArtifactId));
+
+    // Delete associated generations
+    await drizzle
+      .delete(generations)
+      .where(eq(generations.userArtifactId, userArtifactId));
+
+    // Delete the user artifact
+    await drizzle
+      .delete(userArtifacts)
+      .where(eq(userArtifacts.id, userArtifactId));
+
+    await this.log('info', 'Cleaned up stale cosmic mirror artifact', {
+      userArtifactId,
+    });
+  }
+
+  async retryStaleCosmicMirror(userArtifactId: string): Promise<any> {
+    const drizzle = this.context.drizzle();
+    const { users, artifactFaceswap, cosmicMirrorImages, userArtifacts } =
+      schema;
+
+    console.log(
+      `Starting retryStaleCosmicMirror for userArtifactId: ${userArtifactId}`
+    );
+
+    // Fetch userId from userArtifacts
+    console.log('Fetching user artifact to get userId...');
+    const [artifact] = await drizzle
+      .select({ userId: userArtifacts.userId })
+      .from(userArtifacts)
+      .where(eq(userArtifacts.id, userArtifactId))
+      .limit(1);
+
+    if (!artifact || !artifact.userId) {
+      console.error('User artifact or userId not found');
+      return {
+        status: 'error',
+        error: 'User artifact or userId not found',
+        statusCode: 400,
+      };
+    }
+
+    const userId = artifact.userId;
+    console.log(`Fetched userId: ${userId}`);
+
+    // Fetch user photo
+    console.log('Fetching user photo from database...');
+    const [user] = await drizzle
+      .select({
+        userPhotoUrl: users.userPhotoUrl,
+        userProfileImage: users.profileImage,
+      })
+      .from(users)
+      .where(eq(users.id, userId))
+      .limit(1);
+
+    console.log('User fetch result:', user);
+
+    const sourceImage = user?.userPhotoUrl || user?.userProfileImage;
+    if (!sourceImage) {
+      console.error('No user photo found for faceswap');
+      return {
+        status: 'error',
+        error: 'No user photo found for faceswap',
+        statusCode: 400,
+      };
+    }
+    console.log(`Source image URL: ${sourceImage}`);
+
+    // Get all images from D1
+    console.log('Fetching images from D1 cosmicMirrorImages table...');
+    const images = await drizzle
+      .select()
+      .from(cosmicMirrorImages)
+      .where(eq(cosmicMirrorImages.userArtifactId, userArtifactId));
+
+    console.log('Images retrieved from D1:', images);
+
+    if (images.length === 0) {
+      console.warn('No images found in D1 for this userArtifactId');
+      return {
+        status: 'error',
+        error: 'No images found in D1 for faceswap',
+        statusCode: 400,
+      };
+    }
+
+    // Process faceswaps for all images
+    let faceswapCount = 0;
+    for (const image of images) {
+      console.log(`Processing image with leonardoId: ${image.leonardoId}`);
+
+      if (!image.url) {
+        console.warn(
+          `Image with leonardoId ${image.leonardoId} does not contain a URL:`,
+          image
+        );
+        continue;
+      }
+      console.log(
+        `Target image URL for leonardoId ${image.leonardoId}: ${image.url}`
+      );
+
+      console.log(
+        `Calling faceSwap API for source: ${sourceImage}, target: ${image.url}`
+      );
+      let faceSwapResponse: any;
+      try {
+        // Add a timeout for the FaceSwap API call (8 seconds as specified)
+        const timeoutPromise = new Promise((_, reject) => {
+          setTimeout(
+            () =>
+              reject(new Error('FaceSwap API call timed out after 8 seconds')),
+            8000
+          );
+        });
+
+        faceSwapResponse = await Promise.race([
+          this.context.api().callPiApi.faceSwap({
+            sourceImageUrl: sourceImage,
+            targetImageUrl: image.url,
+          }),
+          timeoutPromise,
+        ]);
+
+        console.log(
+          `faceSwap response for leonardoId ${image.leonardoId}:`,
+          faceSwapResponse
+        );
+      } catch (err) {
+        console.error(
+          `faceSwap API call failed for leonardoId ${image.leonardoId}:`,
+          err
+        );
+        continue;
+      }
+
+      if (!faceSwapResponse || !faceSwapResponse.taskId) {
+        console.error(
+          `faceSwap response for leonardoId ${image.leonardoId} does not contain a taskId:`,
+          faceSwapResponse
+        );
+        continue;
+      }
+
+      // Create faceswap record
+      console.log(
+        `Creating artifactFaceswap record for taskId: ${faceSwapResponse.taskId}`
+      );
+      try {
+        await drizzle.insert(artifactFaceswap).values({
+          id: faceSwapResponse.taskId,
+          userArtifactId,
+          status: 'pending',
+          createdAt: new Date(),
+          updatedAt: new Date(),
+        });
+        console.log(
+          `Successfully created artifactFaceswap record for taskId: ${faceSwapResponse.taskId}`
+        );
+        faceswapCount++;
+      } catch (err) {
+        console.error(
+          `Failed to create artifactFaceswap record for taskId: ${faceSwapResponse.taskId}:`,
+          err
+        );
+        continue;
+      }
+    }
+
+    if (faceswapCount === 0) {
+      console.error('No artifactFaceswap records were created');
+      return {
+        status: 'error',
+        error: 'Failed to create any faceswap records',
+        statusCode: 500,
+      };
+    }
+
+    // Update user artifact status
+    console.log(
+      `Updating userArtifacts status to 'faceswap' for userArtifactId: ${userArtifactId}`
+    );
+    try {
+      await drizzle
+        .update(userArtifacts)
+        .set({
+          status: 'faceswap',
+          updatedAt: new Date(),
+        })
+        .where(eq(userArtifacts.id, userArtifactId));
+      console.log('Successfully updated userArtifacts status');
+    } catch (err) {
+      console.error('Failed to update userArtifacts status:', err);
+      return {
+        status: 'error',
+        error: 'Failed to update user artifact status',
+        statusCode: 500,
+      };
+    }
+
+    console.log(
+      `retryStaleCosmicMirror completed successfully. Created ${faceswapCount} faceswap records.`
+    );
+    return {
+      status: 'success',
+      data: {
+        message: 'Restarted faceswap process for existing cosmic mirror images',
+      },
+      statusCode: 200,
+    };
+  }
+}

package/app/services/ImageDescriberService.ts

@@ -0,0 +1,45 @@
+import { inject, injectable } from 'inversify';
+import 'reflect-metadata';
+import { AppContext } from '../base';
+
+@injectable()
+export class ImageDescriberService {
+  constructor(@inject(AppContext) private context: AppContext) {}
+
+  async describeImage({ imageUrl }: { imageUrl: string }): Promise<string> {
+    try {
+      const response = await this.context.api().callTogether.single(
+        [
+          {
+            role: 'user',
+            content: [
+              {
+                type: 'text',
+                text: 'Describe the following traits of the person in the picture:\n- Hair color, size and style\n- Skin color\n- Eye color\n\nReturn the result in the following format:\n\nHair: hair description\nSkin: skin description\nEye: eye color',
+              },
+              {
+                type: 'image_url',
+                image_url: {
+                  url: imageUrl,
+                },
+              },
+            ],
+          },
+        ],
+        {
+          model: 'meta-llama/Llama-3.2-11B-Vision-Instruct-Turbo',
+          temperature: 0.3,
+        }
+      );
+
+      if (!response) {
+        throw new Error('Failed to generate image description');
+      }
+
+      return response;
+    } catch (error) {
+      console.error('Error describing image:', error);
+      throw error;
+    }
+  }
+}

package/app/services/index.ts

@@ -1,3 +1,5 @@
 export * from './ArchetypeService';
+export * from './ArtifactService';
 export * from './ConceptService';
+export * from './ImageDescriberService';
 export * from './LeonardoService';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zodic/shared",
-  "version": "0.0.358",
+  "version": "0.0.359",
   "module": "index.ts",
   "type": "module",
   "publishConfig": {