@yrpri/api 9.0.89 → 9.0.91

package/active-citizen/llms/collectionImageGenerator.js

@@ -16,11 +16,50 @@ const disableFlux = false;
 export class CollectionImageGenerator {
     async resizeImage(imagePath, width, height) {
         const resizedImageFilePath = path.join("/tmp", `${uuidv4()}.png`);
-        await sharp(imagePath)
-            .resize({ width, height })
-            .toFile(resizedImageFilePath);
-        fs.unlinkSync(imagePath);
-        return resizedImageFilePath;
+        try {
+            // 1) Initialize Sharp instance
+            const image = sharp(imagePath).rotate(); // rotate fixes orientation from EXIF
+            // 2) Read metadata to validate format
+            const metadata = await image.metadata();
+            const validFormats = [
+                "jpeg",
+                "png",
+                "webp",
+                "gif",
+                "tiff",
+                "avif",
+                "svg"
+            ];
+            if (!metadata.format || !validFormats.includes(metadata.format)) {
+                throw new Error(`Unsupported format: ${metadata.format} (expected one of ${validFormats.join(", ")})`);
+            }
+            // 3) Resize + convert
+            await image
+                .resize({
+                width,
+                height,
+                fit: "inside",
+                withoutEnlargement: true, // ensures you won't upscale smaller images
+            })
+                .toFormat("png", {
+                quality: 90,
+                progressive: true,
+            })
+                .toFile(resizedImageFilePath);
+            // 4) Remove the original file after successful resize
+            fs.unlinkSync(imagePath);
+            return resizedImageFilePath;
+        }
+        catch (err) {
+            // Cleanup if something goes wrong
+            console.error("Error resizing image:", err);
+            // Optionally remove partial or empty output file if it exists
+            if (fs.existsSync(resizedImageFilePath)) {
+                fs.unlinkSync(resizedImageFilePath);
+            }
+            // Rethrow or handle error further
+            throw err;
+        }
     }
     async downloadImage(imageUrl, imageFilePath) {
         const response = await axios({

package/agents/assistants/baseAssistant.js

@@ -21,7 +21,7 @@ export class YpBaseAssistant extends YpBaseChatBot {
         this.availableTools = new Map();
         this.toolCallTimeout = 30000; // 30 seconds
         this.maxModeTransitions = 10;
-        this.modelName = "gpt-4o";
+        this.modelName = process.env.OPENAI_STREAMING_MODEL_NAME || "gpt-4o-2024-11-20";
         this.defaultSystemPrompt = `<coreImportantSystemInstructions>
 You are a helpful, witty, and friendly AI. Act like a human, but remember that you aren't a human and that you can't do human things in the real world.
 Your voice and personality should be warm and engaging, with a lively and playful tone. Talk quickly.

package/agents/assistants/modes/tools/models/subscriptions.js

@@ -3,6 +3,7 @@ import { YpSubscriptionPlan } from "../../../../models/subscriptionPlan.js";
 import { YpAgentProduct } from "../../../../models/agentProduct.js";
 import { YpAgentProductBundle } from "../../../../models/agentProductBundle.js";
 import { YpAgentProductRun } from "../../../../models/agentProductRun.js";
+import { Op } from "sequelize";
 export class SubscriptionModels {
     constructor(assistant) {
         this.assistant = assistant;
@@ -18,7 +19,10 @@ export class SubscriptionModels {
             // Get all available subscription plans with their associated agent products
             const availablePlans = await YpSubscriptionPlan.findAll({
                 where: {
-                //  status: 'active', // Only get active plans
+                    id: {
+                        [Op.in]: [1, 6],
+                    },
+                    //  status: 'active', // Only get active plans
                 },
                 attributes: ['id', 'configuration', 'name', 'description'],
                 include: [

package/agents/assistants/modes/tools/navigationTools.js

@@ -1,7 +1,7 @@
 // commonTools.ts
-import { AgentModels } from './models/agents.js';
-import { SubscriptionModels } from './models/subscriptions.js';
-import { BaseAssistantTools } from './baseTools.js';
+import { AgentModels } from "./models/agents.js";
+import { SubscriptionModels } from "./models/subscriptions.js";
+import { BaseAssistantTools } from "./baseTools.js";
 export class NavigationTools extends BaseAssistantTools {
     constructor(assistant) {
         super(assistant);
@@ -9,10 +9,10 @@ export class NavigationTools extends BaseAssistantTools {
         this.subscriptionModels = new SubscriptionModels(assistant);
     }
     async goBackToMainAssistant() {
-        await this.assistant.handleModeSwitch('agent_selection_mode', 'User requested to return to the main assistant', {});
+        await this.assistant.handleModeSwitch("agent_selection_mode", "User requested to return to the main assistant", {});
         return {
             success: true,
-            data: { message: 'Returned to main assistant' },
+            data: { message: "Returned to main assistant" },
         };
     }
     get connectDirectlyToAgent() {
@@ -36,12 +36,31 @@ export class NavigationTools extends BaseAssistantTools {
         params = this.assistant.getCleanedParams(params);
         console.log(`handler: connect_to_one_of_the_agents: ${JSON.stringify(params, null, 2)}`);
         try {
-            const { plan, subscription } = await this.subscriptionModels.loadAgentProductPlanAndSubscription(params.subscriptionPlanId);
+            let { plan, subscription } = await this.subscriptionModels.loadAgentProductPlanAndSubscription(params.subscriptionPlanId);
             if (!plan?.AgentProduct) {
                 throw new Error(`Agent product with id ${params.subscriptionPlanId} not found`);
             }
+            //TODO: Does not work as the user is not logged in. Lets figure it out.
+            /*if (plan.configuration.amount == 0) {
+              const result = await this.subscriptionModels.subscribeToAgentPlan(
+                plan.AgentProduct!.id,
+                plan.id
+              );
+      
+              if (!result.success || !result.subscription || !result.plan) {
+                return {
+                  success: false,
+                  error: result.error || "Failed to subscribe to agent plan",
+                };
+              } else {
+                plan = result.plan;
+                subscription = result.subscription;
+              }
+            }*/
             console.log(`Loading: ${plan?.AgentProduct?.name} ${subscription?.id}`);
-            await this.updateCurrentAgentProductPlan(plan, subscription, { sendEvent: false });
+            await this.updateCurrentAgentProductPlan(plan, subscription, {
+                sendEvent: false,
+            });
             await this.assistant.handleModeSwitch("agent_direct_connection_mode", `Directly connected to agent: ${plan?.AgentProduct?.name}`, params);
             const html = `<div class="agent-chips"><yp-agent-chip
           isSelected
@@ -61,9 +80,7 @@ export class NavigationTools extends BaseAssistantTools {
             };
         }
         catch (error) {
-            const errorMessage = error instanceof Error
-                ? error.message
-                : "Failed to select agent";
+            const errorMessage = error instanceof Error ? error.message : "Failed to select agent";
             console.error(`Failed to select agent: ${errorMessage}`);
             return {
                 success: false,

package/agents/assistants/voiceAssistant.js

@@ -19,7 +19,7 @@ export class YpBaseChatBotWithVoice extends YpBaseChatBot {
         };
         // Default voice configuration
         this.voiceConfig = {
-            model: "gpt-4o-realtime-preview-2024-12-17",
+            model: process.env.OPENAI_VOICE_MODEL_NAME || "gpt-4o-realtime-preview-2024-12-17",
             voice: "echo",
             modalities: ["text", "audio"],
         };

package/agents/models/testData/updateAgentWorkflowConfiguration.js

@@ -50,7 +50,7 @@ async function setupAgentProductsConfiguration() {
             },
             {
                 name: "Competitor analysis report",
-                shortName: "Competitor Analysis Report",
+                shortName: "Competitor Report",
                 shortDescription: "Report on the state of your key competitors and recommendations.",
                 description: "Report on the state of your key competitors where all the information gathered in earlier steps has been consolidated into chapters for each competitor and concludes with a chapter on action-oriented recommendations.",
                 agentClassUuid: "1cf3af64-a5f6-a7c1-91c1-51fb13c72f1a",

package/controllers/images.cjs

@@ -222,26 +222,71 @@ router.post("/:imageId/comment", auth.isLoggedInNoAnonymousCheck, auth.can("view
 router.post("/", isAuthenticated, async function (req, res) {
     try {
         const s3 = new aws.S3();
-        //TODO: Look into making animated gifs work through sharp
-        const isGif = req.file && req.file.originalname.toLowerCase().indexOf(".gif");
+        // 1) Check if the file name ends with ".gif"
+        const isGifFilename = (filename) => {
+            const lowerCaseFilename = filename.toLowerCase();
+            console.log("filename===========>", filename);
+            console.log("lowerCaseFilename===========>", lowerCaseFilename);
+            return lowerCaseFilename.endsWith(".gif");
+        };
+        // 2) Create the storage with a Key callback that uses 'isGifFilename'
         const storage = s3Storage({
             Key: (req, file, cb) => {
                 crypto.pseudoRandomBytes(16, (err, raw) => {
-                    cb(err, err ? undefined : `${raw.toString("hex")}.${isGif ? "gif" : "png"}`);
+                    if (err)
+                        return cb(err);
+                    const rawHex = raw.toString("hex");
+                    console.log("file.originalname", file.originalname);
+                    const isGif = isGifFilename(file.originalname);
+                    console.log("gif===========>", isGif);
+                    file.outputFormat = isGif ? "gif" : "png";
+                    cb(null, `${rawHex}.${isGif ? "gif" : "png"}`);
                 });
             },
             s3,
             Bucket: process.env.S3_BUCKET,
             multiple: true,
             resize: models.Image.getSharpVersions(req.query.itemType),
-            toFormat: isGif ? "gif" : "png",
+            toFormat: "png",
         });
-        const upload = multer({ storage });
+        // 3) Allowed MIME types that Sharp commonly supports
+        //    (Adjust or expand as needed)
+        const allowedMimeTypes = [
+            "image/png",
+            "image/jpeg",
+            "image/jpg",
+            "image/gif",
+            "image/webp",
+            "image/tiff",
+            "image/svg+xml"
+        ];
+        // 4) A fileFilter to reject non-image or invalid Sharp formats
+        const fileFilter = (req, file, cb) => {
+            console.log("file------------>", file);
+            // Check that it's an image and specifically in our allowed list
+            if (!allowedMimeTypes.includes(file.mimetype.toLowerCase())) {
+                return cb(new Error(`Unsupported file type: ${file.mimetype}. Allowed: ${allowedMimeTypes.join(", ")}`));
+            }
+            cb(null, true);
+        };
+        // 5) Construct multer with:
+        //    - the custom S3-based storage
+        //    - our fileFilter for validation
+        //    - a file size limit of 50MB (you can adjust as needed)
+        const upload = multer({
+            storage,
+            fileFilter,
+            limits: { fileSize: 50 * 1024 * 1024 } // 50MB limit
+        });
+        // 6) Use upload.single, handle the success/error callback carefully
         upload.single("file")(req, res, async function (error) {
             if (error) {
-                sendError(res, req.file ? req.file.originalname : "unknown filename", "create", res.user, error);
+                // Multer will throw if file is too large or invalid
+                console.error("File upload error:", error);
+                return res.status(400).json({ error: error.message });
             }
-            else {
+            // Continue if there's a valid image file
+            try {
                 const formats = JSON.stringify(models.Image.createFormatsFromSharpFile(req.file));
                 const image = models.Image.build({
                     user_id: req.user.id,
@@ -257,12 +302,21 @@ router.post("/", isAuthenticated, async function (req, res) {
                     context: "create",
                     userId: req.user ? req.user.id : -1,
                 });
-                res.send(image);
+                return res.send(image);
+            }
+            catch (err) {
+                console.error("Error saving image record:", err);
+                return res.status(500).json({ error: "Failed to save image record" });
             }
         });
     }
-    catch (error) {
-        sendError(res, req.file.originalname, "create", res.user, error);
+    catch (err) {
+        console.error("Unexpected error:", err);
+        // If req.file exists, use its data; otherwise fallback
+        const fileName = req.file ? req.file.originalname : "unknown filename";
+        return res.status(500).json({
+            error: `Unhandled error while processing '${fileName}'`,
+        });
     }
 });
 // Post User Images

package/controllers/nonSpa.cjs

@@ -554,7 +554,7 @@ router.get('/*', function botController(req, res, next) {
         ], error => {
             if (error) {
                 log.error("Id for nonSpa is not a number", { error });
-                res.sendStatus(404);
+                res.sendStatus(200);
             }
             else {
                 if (req.ypCommunity && req.ypCommunity.id != null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yrpri/api",
-  "version": "9.0.89",
+  "version": "9.0.91",
   "license": "MIT",
   "author": "Robert Bjarnason & Citizens Foundation",
   "repository": {
@@ -94,7 +94,7 @@
     "sanitize-filename": "^1.6.3",
     "sequelize": "^6.36.0",
     "sequelize-cli": "^6.2.0",
-    "sharp": "^0.33.2",
+    "sharp": "^0.33.5",
     "sitemap": "^7.1.2",
     "socket.io": "^4.0.0",
     "stripe": "^17.3.0",

package/scripts/cleanups/deleteAnonNotifications.cjs

@@ -0,0 +1,91 @@
+"use strict";
+const models = require('../../models/index.cjs');
+const moment = require('moment');
+const maxNumberFromPath = process.argv[2];
+const maxNumberOfNotificationsToDelete = maxNumberFromPath ? maxNumberFromPath : 1000;
+let numberOfDeletedNotifications = 0;
+let startTime = moment();
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+const chunk = (arr, size) => Array.from({ length: Math.ceil(arr.length / size) }, (v, i) => arr.slice(i * size, i * size + size));
+(async () => {
+    let haveNotificationsToDelete = true;
+    let userOffset = 0;
+    while (haveNotificationsToDelete && numberOfDeletedNotifications < maxNumberOfNotificationsToDelete) {
+        try {
+            const users = await models.User.unscoped().findAll({
+                where: {
+                    created_at: {
+                        [models.Sequelize.Op.lte]: moment().add(-3, 'days').toISOString()
+                    },
+                    profile_data: {
+                        isAnonymousUser: {
+                            [models.Sequelize.Op.is]: true
+                        }
+                    }
+                },
+                attributes: ['id'],
+                order: ['id'],
+                offset: userOffset,
+                limit: 500
+            });
+            if (users.length > 0) {
+                console.log(`${users.length} users offset ${userOffset}`);
+                userOffset += 500;
+                const userIds = users.map(n => { return n.id; });
+                let haveNotificationsLeftToProcess = true;
+                let notificationsOffset = 0;
+                while (haveNotificationsLeftToProcess && numberOfDeletedNotifications < maxNumberOfNotificationsToDelete) {
+                    const notifications = await models.AcNotification.unscoped().findAll({
+                        where: {
+                            user_id: {
+                                [models.Sequelize.Op.in]: userIds
+                            }
+                        },
+                        limit: 1000,
+                        offset: notificationsOffset,
+                        order: ['user_id'],
+                        attributes: ['id'],
+                    });
+                    console.log(`${notifications.length} notifications offset ${notificationsOffset}`);
+                    if (notifications.length > 0) {
+                        notificationsOffset += 1000;
+                        const notificationIds = notifications.map(n => { return n.id; });
+                        const chunkedIds = chunk(notificationIds, 100);
+                        for (let i = 0; i < chunkedIds.length; i++) {
+                            const destroyInfo = await models.AcNotification.unscoped().destroy({
+                                where: {
+                                    id: {
+                                        [models.Sequelize.Op.in]: chunkedIds[i]
+                                    }
+                                }
+                            });
+                            numberOfDeletedNotifications += destroyInfo;
+                            console.log(`${numberOfDeletedNotifications}`);
+                            await sleep(50);
+                            if (numberOfDeletedNotifications >= maxNumberOfNotificationsToDelete) {
+                                break;
+                            }
+                        }
+                    }
+                    else {
+                        haveNotificationsLeftToProcess = false;
+                        console.log("No more notifications left to process from user");
+                    }
+                    await sleep(100);
+                }
+            }
+            else {
+                haveNotificationsToDelete = false;
+            }
+        }
+        catch (error) {
+            console.error(error);
+            haveNotificationsToDelete = false;
+        }
+    }
+    console.log(`${numberOfDeletedNotifications} old anon notifications deleted`);
+    console.log(`Duration ${moment(moment() - startTime).format("HH:mm:ss.SSS")}`);
+    process.exit();
+})();

package/scripts/cleanups/deleteYearOldNotifications.cjs

@@ -0,0 +1,72 @@
+"use strict";
+const models = require('../../models/index.cjs');
+const moment = require('moment');
+const maxNumberFromPath = process.argv[2];
+// Default to 1,000,000 if no command line arg given, adjust as you see fit
+const maxNumberOfNotificationsToDelete = maxNumberFromPath ? parseInt(maxNumberFromPath) : 1000000;
+let numberOfDeletedNotifications = 0;
+const startTime = moment();
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function chunk(arr, size) {
+    return Array.from({ length: Math.ceil(arr.length / size) }, (_, i) => arr.slice(i * size, i * size + size));
+}
+(async () => {
+    let haveNotificationsToDelete = true;
+    let offset = 0;
+    // Calculate the cutoff date for "older than 1 year"
+    const cutoffDate = moment().subtract(1, 'year').toISOString();
+    while (haveNotificationsToDelete && numberOfDeletedNotifications < maxNumberOfNotificationsToDelete) {
+        try {
+            // Fetch a batch of notifications older than 1 year
+            const notifications = await models.AcNotification.unscoped().findAll({
+                where: {
+                    created_at: {
+                        [models.Sequelize.Op.lte]: cutoffDate,
+                    },
+                },
+                limit: 1000,
+                offset: offset,
+                order: ['id'],
+                attributes: ['id'],
+            });
+            if (notifications.length > 0) {
+                console.log(`${notifications.length} notifications found at offset ${offset}`);
+                offset += 1000;
+                // Extract IDs and chunk them to avoid huge deletions in one query
+                const notificationIds = notifications.map(n => n.id);
+                const chunkedIds = chunk(notificationIds, 100);
+                // Delete chunk by chunk
+                for (const chunkIds of chunkedIds) {
+                    const destroyInfo = await models.AcNotification.unscoped().destroy({
+                        where: {
+                            id: {
+                                [models.Sequelize.Op.in]: chunkIds,
+                            },
+                        },
+                    });
+                    numberOfDeletedNotifications += destroyInfo;
+                    console.log(`Total deleted so far: ${numberOfDeletedNotifications}`);
+                    await sleep(10); // short pause
+                    // Stop if we’ve hit our daily (or run) limit
+                    if (numberOfDeletedNotifications >= maxNumberOfNotificationsToDelete) {
+                        break;
+                    }
+                }
+            }
+            else {
+                // No more notifications to delete
+                haveNotificationsToDelete = false;
+            }
+            await sleep(25); // short pause between big fetches
+        }
+        catch (error) {
+            console.error(error);
+            haveNotificationsToDelete = false;
+        }
+    }
+    console.log(`${numberOfDeletedNotifications} old notifications deleted`);
+    console.log(`Duration: ${moment(moment() - startTime).format('HH:mm:ss.SSS')}`);
+    process.exit();
+})();

package/utils/sitemap_generator.cjs

@@ -68,6 +68,10 @@ var generateSitemap = async function (req, res) {
                         })
                             .then(function (communities) {
                             _.forEach(communities, function (community) {
+                                if (!community) {
+                                    console.error("No community found in sitemap generation");
+                                    return;
+                                }
                                 const path = "/community/" + community.id;
                                 if (community.hostname &&
                                     wildCardDomainNames.indexOf(domainName) > -1) {
@@ -134,6 +138,10 @@ var generateSitemap = async function (req, res) {
                     })
                         .then(function (groups) {
                         _.forEach(groups, function (group) {
+                            if (!group) {
+                                console.error("No group found in sitemap generation");
+                                return;
+                            }
                             const path = "/group/" + group.id;
                             if (group.Community.hostname &&
                                 wildCardDomainNames.indexOf(domainName) > -1) {
@@ -217,6 +225,10 @@ var generateSitemap = async function (req, res) {
                         })
                             .then(function (posts) {
                             _.forEach(posts, function (post) {
+                                if (!post) {
+                                    console.error("No post found in sitemap generation");
+                                    return;
+                                }
                                 links.push({ url: "/post/" + post.id });
                             });
                             seriesCallback();