@yrpri/api 9.0.102 → 9.0.104

package/active-citizen/llms/imageGeneration/chatGptImageGenerator.js

@@ -0,0 +1,56 @@
+// chatGptImageGenerator.ts
+import { OpenAI } from "openai";
+export class ChatGptImageGenerator {
+    constructor(openAiKey) {
+        this.maxRetryCount = 3;
+        // the SDK will fall back to process.env.OPENAI_API_KEY if nothing is passed
+        this.openAiKey = openAiKey;
+    }
+    /**
+     * Generates an image URL from a prompt using OpenAI’s gpt-image-1 model.
+     * The returned link remains live for ~60 minutes – be sure to download
+     * or cache it right away in the calling service.
+     */
+    async generateImageUrl(prompt, type = "logo") {
+        const client = new OpenAI({ apiKey: this.openAiKey });
+        // Pick a sensible canvas size from the image type
+        let size = "1536x1024";
+        if (type === "icon")
+            size = "1024x1024";
+        else if (type === "other")
+            size = "1536x1024";
+        const finalPrompt = `
+    ${prompt}
+
+    Instruction: Create a high quality logo like image for the users project and follow their style instructions. \
+    Do not add text to the images unless asked in the style instructions.
+    `;
+        let retryCount = 0;
+        while (retryCount < this.maxRetryCount) {
+            try {
+                const res = await client.images.generate({
+                    model: "gpt-image-1",
+                    prompt: finalPrompt,
+                    quality: "medium",
+                    n: 1,
+                    size
+                });
+                const url = res?.data?.[0]?.url;
+                if (url)
+                    return url;
+                throw new Error("No URL returned");
+            }
+            catch (err) {
+                retryCount += 1;
+                if (retryCount >= this.maxRetryCount) {
+                    console.error(`ChatGptImageGenerator failed after ${retryCount} attempts`, err);
+                    return undefined;
+                }
+                // Exponential back-off – starts at 5 s and grows +5 s each retry
+                await new Promise((r) => setTimeout(r, 5000 + retryCount * 5000));
+            }
+        }
+        return undefined;
+    }
+}
+export default ChatGptImageGenerator;

package/active-citizen/llms/imageGeneration/collectionImageGenerator.js

@@ -9,6 +9,7 @@ import { S3Service } from "./s3Service.js";
 // Suppose these come from your codebase
 import models from "../../../models/index.cjs";
 import { ImagenImageGenerator } from "./imagenImageGenerator.js";
+import { ChatGptImageGenerator } from "./chatGptImageGenerator.js";
 // For reference, in your code:
 const dbModels = models;
 const Image = dbModels.Image;
@@ -26,6 +27,7 @@ export class CollectionImageGenerator {
             this.fluxImageGenerator = new FluxImageGenerator(process.env.REPLICATE_API_TOKEN, process.env.FLUX_PRO_MODEL_NAME);
         }
         this.dalleImageGenerator = new DalleImageGenerator(process.env.AZURE_OPENAI_API_BASE, process.env.AZURE_OPENAI_API_KEY, process.env.AZURE_OPENAI_API_DALLE_DEPLOYMENT_NAME, process.env.OPENAI_API_KEY);
+        this.chatGptImageGenerator = new ChatGptImageGenerator(process.env.OPENAI_API_KEY);
         if (useImagen && process.env.GOOGLE_CLOUD_PROJECT_ID) {
             this.imagenImageGenerator = new ImagenImageGenerator(this.s3Service);
         }
@@ -50,6 +52,10 @@ export class CollectionImageGenerator {
                     imageGenerator = this.fluxImageGenerator;
                     console.info("Using FluxImageGenerator");
                 }
+                else if (process.env.USE_CHATGPT_IMAGE_GENERATOR) {
+                    imageGenerator = this.chatGptImageGenerator;
+                    console.info("Using ChatGptImageGenerator");
+                }
                 else {
                     imageGenerator = this.dalleImageGenerator;
                     console.info("Using DalleImageGenerator");

package/agents/controllers/agentProductController.js

@@ -22,7 +22,8 @@ export class AgentProductController {
                 const agentProductId = parseInt(req.params.agentProductId);
                 const agentProduct = await this.agentProductManager.getAgentProduct(agentProductId);
                 if (!agentProduct) {
-                    return res.status(404).json({ error: 'Agent product not found' });
+                    res.status(404).json({ error: 'Agent product not found' });
+                    return;
                 }
                 res.json(agentProduct);
             }

package/agents/controllers/agentSubscriptionController.js

@@ -21,22 +21,25 @@ export class AgentSubscriptionController {
                         },
                     });
                     if (!subscription) {
-                        return res.status(404).json({ error: "Subscription not found" });
+                        res.status(404).json({ error: "Subscription not found" });
+                        return;
                     }
                     // Extract the requiredQuestionsAnswered from subscription.configuration
                     const answers = subscription.configuration?.requiredQuestionsAnswered || [];
-                    return res.status(200).json({
+                    res.status(200).json({
                         success: true,
                         data: answers,
                     });
+                    return;
                 }
                 else {
-                    return res.status(401).json({ error: "Unauthorized" });
+                    res.status(401).json({ error: "Unauthorized" });
+                    return;
                 }
             }
             catch (error) {
                 console.error("Error retrieving subscription agent configuration:", error);
-                return res.status(500).json({ error: error.message });
+                res.status(500).json({ error: error.message });
             }
         };
         this.updateAgentConfiguration = async (req, res) => {
@@ -44,13 +47,15 @@ export class AgentSubscriptionController {
                 const subscriptionId = parseInt(req.params.subscriptionId);
                 const requiredQuestionsAnswered = req.body.requiredQuestionsAnswered;
                 if (!requiredQuestionsAnswered) {
-                    return res.status(400).json({ error: "requiredQuestionsAnswered is required" });
+                    res.status(400).json({ error: "requiredQuestionsAnswered is required" });
+                    return;
                 }
                 const subscription = await YpSubscription.findOne({
                     where: { id: subscriptionId, user_id: req.user.id }
                 });
                 if (!subscription) {
-                    return res.status(404).json({ error: "Subscription not found" });
+                    res.status(404).json({ error: "Subscription not found" });
+                    return;
                 }
                 subscription.configuration.requiredQuestionsAnswered = JSON.parse(requiredQuestionsAnswered);
                 subscription.changed('configuration', true);
@@ -78,13 +83,13 @@ export class AgentSubscriptionController {
                 const userId = req.user.id;
                 // If not a free trial request, redirect to payment intent endpoint
                 if (!isFreeTrialRequest) {
-                    return res.status(400).json({
+                    res.status(400).json({
                         error: "For paid subscriptions, please use /stripe-create-payment-intent instead",
                     });
                 }
                 // Handle free trial subscription
                 if (!planIds) {
-                    return res.status(400).json({
+                    res.status(400).json({
                         error: "agentProductIds and planIds are required",
                     });
                 }
@@ -146,7 +151,8 @@ export class AgentSubscriptionController {
                     where: { id: subscriptionId, user_id: userId },
                 });
                 if (!subscription) {
-                    return res.status(404).json({ error: "Subscription not found" });
+                    res.status(404).json({ error: "Subscription not found" });
+                    return;
                 }
                 subscription.status = "cancelled";
                 await subscription.save();
@@ -166,7 +172,8 @@ export class AgentSubscriptionController {
                     where: { id: subscriptionId, user_id: userId },
                 });
                 if (!subscription) {
-                    return res.status(404).json({ error: "Subscription not found" });
+                    res.status(404).json({ error: "Subscription not found" });
+                    return;
                 }
                 // Apply updates (validate as necessary)
                 Object.assign(subscription, updates);
@@ -183,15 +190,17 @@ export class AgentSubscriptionController {
                 const userId = req.user.id;
                 const { planIds, paymentMethodId } = req.body;
                 if (!planIds || !paymentMethodId) {
-                    return res.status(400).json({
+                    res.status(400).json({
                         error: "planIds, and paymentMethodId are required",
                     });
+                    return;
                 }
                 const result = await this.subscriptionManager.createSubscriptions(userId, planIds, paymentMethodId);
                 res.status(200).json({
                     clientSecret: result.clientSecret,
                     subscriptionId: result.subscriptionId,
                 });
+                return;
             }
             catch (error) {
                 console.error("Error creating payment intent:", error);

package/agents/controllers/assistantsController.js

@@ -53,28 +53,33 @@ export class AssistantController {
                 const { agentId } = req.params;
                 let lastStatusMessage = await this.getLastStatusMessageFromDB(parseInt(agentId));
                 if (!lastStatusMessage) {
-                    return res.status(404).send("No status message found.");
+                    res.status(404).send("No status message found.");
                 }
                 const regex = /<markdownReport>([\s\S]*?)<\/markdownReport>/i;
-                const match = lastStatusMessage.match(regex);
+                const match = lastStatusMessage ? lastStatusMessage.match(regex) : null;
                 console.debug(`match: ${JSON.stringify(match, null, 2)}`);
                 if (!match || match.length < 2) {
                     console.error("No <markdownReport>...</markdownReport> content found.");
-                    return res
+                    res
                         .status(400)
                         .send("No <markdownReport>...</markdownReport> content found.");
                 }
-                const markdownContent = match[1];
+                const markdownContent = match ? match[1] : null;
+                if (!markdownContent) {
+                    console.error("No markdown content found.");
+                    res.status(400).send("No markdown content found.");
+                    return;
+                }
                 const htmlContent = await marked(markdownContent);
                 const docxBuffer = (await HTMLtoDOCX(htmlContent));
                 console.debug(`docxBuffer: ${docxBuffer.length}`);
                 res.setHeader("Content-Type", "application/vnd.openxmlformats-officedocument.wordprocessingml.document");
                 res.setHeader("Content-disposition", 'attachment; filename="converted.docx"');
-                return res.send(docxBuffer);
+                res.send(docxBuffer);
             }
             catch (error) {
                 console.error("Error converting Markdown to DOCX:", error);
-                return res.status(500).send("Server error");
+                res.status(500).send("Server error");
             }
         };
         this.advanceOrStopCurrentWorkflowStep = async (req, res) => {
@@ -115,7 +120,8 @@ export class AssistantController {
         this.getAgentConfigurationAnswers = async (req, res) => {
             try {
                 if (!req.user) {
-                    return res.status(401).json({ error: "Unauthorized" });
+                    res.status(401).json({ error: "Unauthorized" });
+                    return;
                 }
                 const subscriptionId = parseInt(req.params.subscriptionId);
                 // Make sure the user can only fetch their own subscription
@@ -126,25 +132,26 @@ export class AssistantController {
                     },
                 });
                 if (!subscription) {
-                    return res.status(404).json({ error: "Subscription not found" });
+                    res.status(404).json({ error: "Subscription not found" });
                 }
                 // Extract the requiredQuestionsAnswered from subscription.configuration
-                const answers = subscription.configuration?.requiredQuestionsAnswered || [];
-                return res.status(200).json({
+                const answers = subscription?.configuration?.requiredQuestionsAnswered || [];
+                res.status(200).json({
                     success: true,
                     data: answers,
                 });
             }
             catch (error) {
                 console.error("Error retrieving subscription agent configuration:", error);
-                return res.status(500).json({ error: error.message });
+                res.status(500).json({ error: error.message });
             }
         };
         this.getUpdatedWorkflow = async (req, res) => {
             const { runId } = req.params;
             const userId = req.user?.id;
             if (!userId) {
-                return res.status(401).json({ error: "Unauthorized" });
+                res.status(401).json({ error: "Unauthorized" });
+                return;
             }
             try {
                 const agentRun = await YpAgentProductRun.findOne({
@@ -208,13 +215,13 @@ export class AssistantController {
             catch (error) {
                 console.error("Error saving subscription:", error);
                 res.sendStatus(500);
-                return;
             }
             res.sendStatus(200);
         };
         this.updateAssistantMemoryLoginStatus = async (req, res) => {
             if (!req.user) {
-                return res.status(401).json({ error: "Unauthorized" });
+                res.status(401).json({ error: "Unauthorized" });
+                return;
             }
             try {
                 const memory = await this.loadMemoryWithOwnership(req, res);
@@ -275,12 +282,13 @@ export class AssistantController {
             if (!memory)
                 return;
             console.log(`Getting memory at key: ${memory.redisKey}`);
-            return res.json(memory);
+            res.json(memory);
         };
         // New API endpoints for workflow management
         this.getRunningWorkflowConversations = async (req, res) => {
             if (!req.user || !req.user.id) {
-                return res.status(401).json({ error: "Unauthorized" });
+                res.status(401).json({ error: "Unauthorized" });
+                return;
             }
             try {
                 const workflows = await this.workflowConversationManager.getRunningWorkflowConversationsForUser(req.user.id);
@@ -297,7 +305,8 @@ export class AssistantController {
         };
         this.getAllWorkflowConversations = async (req, res) => {
             if (!req.user || !req.user.id) {
-                return res.status(401).json({ error: "Unauthorized" });
+                res.status(401).json({ error: "Unauthorized" });
+                return;
             }
             try {
                 const workflows = await this.workflowConversationManager.getWorkflowConversationsForUser(req.user.id);
@@ -314,7 +323,8 @@ export class AssistantController {
         };
         this.connectToWorkflowConversation = async (req, res) => {
             if (!req.user || !req.user.id) {
-                return res.status(401).json({ error: "Unauthorized" });
+                res.status(401).json({ error: "Unauthorized" });
+                return;
             }
             try {
                 const { workflowConversationId, connectionData } = req.body;

package/agents/controllers/policySynthAgents.js

@@ -22,23 +22,24 @@ export class PolicySynthAgentsController {
                 console.log(`Attempting to replace memory for agent ${agentId} in group ${groupId}`);
                 if (!memory || Object.keys(memory).length === 0) {
                     console.log(`Received empty memory for agent ${agentId}`);
-                    return res.status(400).json({ error: "Cannot save empty memory" });
+                    res.status(400).json({ error: "Cannot save empty memory" });
+                    return;
                 }
                 try {
                     JSON.parse(JSON.stringify(memory));
                 }
                 catch (jsonError) {
                     console.log(`Received invalid JSON for agent ${agentId}`);
-                    return res
-                        .status(400)
-                        .json({ error: "Invalid JSON format for memory" });
+                    res.status(400).json({ error: "Invalid JSON format for memory" });
+                    return;
                 }
                 const memoryKey = await this.agentManager.getSubAgentMemoryKey(groupId, parseInt(agentId));
                 if (!memoryKey) {
                     console.log(`Memory key not found for agent ${agentId}`);
-                    return res
+                    res
                         .status(404)
                         .json({ error: "Memory key not found for the specified agent" });
+                    return;
                 }
                 console.log(`Memory key found: ${memoryKey}`);
                 await req.redisClient.set(memoryKey, JSON.stringify(memory));
@@ -53,15 +54,29 @@ export class PolicySynthAgentsController {
                 else {
                     res.status(500).json({ error: "An unexpected error occurred" });
                 }
+                return;
             }
         };
         this.addExistingConnector = async (req, res) => {
-            const { groupId, agentId, type } = req.params;
+            const { groupId, agentId } = req.params;
             const { connectorId } = req.body;
+            let type;
+            if (req.path.includes("/inputConnectors/")) {
+                type = "input";
+            }
+            else if (req.path.includes("/outputConnectors/")) {
+                type = "output";
+            }
+            else {
+                // This case should ideally not be reached if routes are set up correctly
+                res.status(400).send("Could not determine connector type from path");
+                return;
+            }
             if (!groupId || !agentId || !connectorId) {
-                return res
+                res
                     .status(400)
                     .send("Group ID, agent ID and connector ID (input/output) are required");
+                return;
             }
             try {
                 await this.agentConnectorManager.addExistingConnector(parseInt(groupId), parseInt(agentId), parseInt(connectorId), type);
@@ -86,15 +101,17 @@ export class PolicySynthAgentsController {
                 const memoryKey = await this.agentManager.getSubAgentMemoryKey(groupId, parseInt(agentId));
                 if (!memoryKey) {
                     console.log(`Memory key not found for agent ${agentId}`);
-                    return res
+                    res
                         .status(404)
                         .json({ error: "Memory key not found for the specified agent" });
+                    return;
                 }
                 console.log(`Memory key found: ${memoryKey}`);
                 const memoryContents = await req.redisClient.get(memoryKey);
                 if (!memoryContents) {
                     console.log(`Memory contents not found for key ${memoryKey}`);
-                    return res.status(404).json({ error: "Memory contents not found" });
+                    res.status(404).json({ error: "Memory contents not found" });
+                    return;
                 }
                 console.log(`Memory contents retrieved successfully`);
                 const parsedMemoryContents = JSON.parse(memoryContents);
@@ -108,6 +125,7 @@ export class PolicySynthAgentsController {
                 else {
                     res.status(500).json({ error: "An unexpected error occurred" });
                 }
+                return;
             }
         };
         this.getAgent = async (req, res) => {
@@ -118,6 +136,7 @@ export class PolicySynthAgentsController {
             catch (error) {
                 console.error("Error in getAgent:", error);
                 res.status(500).send("Internal Server Error");
+                return;
             }
         };
         this.getAgentAiModels = async (req, res) => {
@@ -163,13 +182,15 @@ export class PolicySynthAgentsController {
                     await this.agentConnectorManager.updateConnectorConfiguration(nodeId, updatedConfig);
                 }
                 else {
-                    return res.status(400).send("Invalid node type");
+                    res.status(400).send("Invalid node type");
+                    return;
                 }
                 res.json({ message: `${nodeType} configuration updated successfully` });
             }
             catch (error) {
                 console.error(`Error updating ${nodeType} configuration:`, error);
                 res.status(500).send("Internal Server Error");
+                return;
             }
         };
         this.createInputConnector = async (req, res) => {
@@ -388,8 +409,8 @@ export class PolicySynthAgentsController {
         this.router.get("/:groupId/:id/ai-models", auth.can("view group"), this.getAgentAiModels);
         this.router.delete("/:groupId/:agentId/ai-models/:modelId", auth.can("edit group"), this.removeAgentAiModel);
         this.router.post("/:groupId/:agentId/ai-models", auth.can("edit group"), this.addAgentAiModel);
-        this.router.get("/:groupId/:agentId/memory", auth.can("view group"), this.getAgentMemory);
         this.router.put("/:groupId/:agentId/memory", auth.can("edit group"), this.replaceAgentMemory);
-        this.router.post("/:groupId/:agentId/:type(input|output)Connectors/existing", auth.can("edit group"), this.addExistingConnector);
+        this.router.post("/:groupId/:agentId/inputConnectors/existing", auth.can("edit group"), this.addExistingConnector);
+        this.router.post("/:groupId/:agentId/outputConnectors/existing", auth.can("edit group"), this.addExistingConnector);
     }
 }

package/agents/managers/newAiModelSetup.js

@@ -336,6 +336,99 @@ export class NewAiModelSetup {
         else {
             console.log("OpenAI model already exists: GPT-4.5 Preview updating");
         }
+        const openAio3 = await PsAiModel.findOne({
+            where: { name: "o3" },
+        });
+        const openAio3Config = {
+            type: PsAiModelType.TextReasoning,
+            modelSize: PsAiModelSize.Medium,
+            provider: "openai",
+            prices: {
+                costInTokensPerMillion: 10.0,
+                costOutTokensPerMillion: 40.0,
+                cacheCostInTokensPerMillion: 2.5,
+                currency: "USD",
+            },
+            maxTokensOut: 100000,
+            defaultTemperature: 0.0,
+            model: "o3",
+            active: true,
+        };
+        if (!openAio3) {
+            await PsAiModel.create({
+                name: "o3",
+                organization_id: 1,
+                user_id: userId,
+                configuration: openAio3Config,
+            });
+            console.log("Created OpenAI model: o3");
+        }
+        else {
+            console.log("OpenAI model already exists: o3 updating");
+            openAio3.set("configuration", openAio3Config);
+            openAio3.changed("configuration", true);
+            await openAio3.save();
+        }
+        const openAio4mini = await PsAiModel.findOne({
+            where: { name: "o4 mini" },
+        });
+        const openAio4miniConfig = {
+            type: PsAiModelType.TextReasoning,
+            modelSize: PsAiModelSize.Small,
+            provider: "openai",
+            prices: {
+                costInTokensPerMillion: 1.1,
+                costOutTokensPerMillion: 4.4,
+                cacheCostInTokensPerMillion: 0.275,
+                currency: "USD",
+            },
+            maxTokensOut: 100000,
+            defaultTemperature: 0.0,
+            model: "o4-mini",
+            active: true,
+        };
+        if (!openAio4mini) {
+            await PsAiModel.create({
+                name: "o4 mini",
+                organization_id: 1,
+                user_id: userId,
+                configuration: openAio4miniConfig,
+            });
+            console.log("Created OpenAI model: o4 mini");
+        }
+        else {
+            console.log("OpenAI model already exists: o4 mini");
+        }
+        const openAiGpt41 = await PsAiModel.findOne({
+            where: { name: "GPT-4.1" },
+        });
+        const openAiGpt41Config = {
+            type: PsAiModelType.Text,
+            modelSize: PsAiModelSize.Medium,
+            provider: "openai",
+            prices: {
+                costInTokensPerMillion: 2,
+                costOutTokensPerMillion: 8,
+                currency: "USD",
+                cacheCostInTokensPerMillion: 0.5
+            },
+            maxTokensOut: 100000,
+            defaultTemperature: 0.7,
+            model: "gpt-4.1",
+            active: true,
+        };
+        if (!openAiGpt41) {
+            await PsAiModel.create({
+                name: "GPT-4.1",
+                organization_id: 1,
+                user_id: userId,
+                configuration: openAiGpt41Config,
+            });
+            console.log("Created OpenAI model: GPT-4.1");
+        }
+        else {
+            console.log("OpenAI model already exists: GPT-4.1");
+        }
     }
     /**
      * Seeds Google models.
@@ -533,6 +626,9 @@ export class NewAiModelSetup {
             { name: "Gemini 2.0 Flash", envKey: "GEMINI_API_KEY" },
             { name: "o1 24", envKey: "OPENAI_API_KEY" },
             { name: "o3 mini", envKey: "OPENAI_API_KEY" },
+            { name: "o4 mini", envKey: "OPENAI_API_KEY" },
+            { name: "GPT-4.1", envKey: "OPENAI_API_KEY" },
+            { name: "o3", envKey: "OPENAI_API_KEY" },
         ];
         const groupAccessConfig = [];
         for (const { name, envKey } of modelsMapping) {

package/agents/managers/subscriptionManager.js

@@ -321,7 +321,7 @@ export class SubscriptionManager {
                 return { freeSubscription: true };
             }
             const stripe = new Stripe(process.env.STRIPE_SECRET_KEY, {
-                apiVersion: "2025-01-27.acacia",
+                apiVersion: "2025-04-30.basil",
             });
             // Create a PaymentIntent with Stripe
             const paymentIntent = await stripe.paymentIntents.create({
@@ -359,7 +359,7 @@ export class SubscriptionManager {
     async handleSuccessfulPayment(paymentIntentId) {
         try {
             const stripe = new Stripe(process.env.STRIPE_SECRET_KEY, {
-                apiVersion: "2025-01-27.acacia",
+                apiVersion: "2025-04-30.basil",
             });
             const paymentIntent = await stripe.paymentIntents.retrieve(paymentIntentId);
             if (paymentIntent.status !== "succeeded") {

package/app.js

@@ -559,19 +559,19 @@ export class YourPrioritiesApi {
         // Promotion app
         const promotionAppPath = path.join(baseDir, "old/promotion_app/dist");
         this.app.use("/promotion", express.static(promotionAppPath));
-        this.app.use("/promotion/domain/*", express.static(promotionAppPath));
-        this.app.use("/promotion/organization/*", express.static(promotionAppPath));
-        this.app.use("/promotion/community/*", express.static(promotionAppPath));
-        this.app.use("/promotion/group/*", express.static(promotionAppPath));
-        this.app.use("/promotion/post/*", express.static(promotionAppPath));
-        this.app.use("/promotion/locales/en/*", express.static(path.join(promotionAppPath, "locales/en")));
-        this.app.use("/promotion/locales/is/*", express.static(path.join(promotionAppPath, "locales/is")));
+        this.app.use("/promotion/domain/*splat", express.static(promotionAppPath));
+        this.app.use("/promotion/organization/*splat", express.static(promotionAppPath));
+        this.app.use("/promotion/community/*splat", express.static(promotionAppPath));
+        this.app.use("/promotion/group/*splat", express.static(promotionAppPath));
+        this.app.use("/promotion/post/*splat", express.static(promotionAppPath));
+        this.app.use("/promotion/locales/en/*splat", express.static(path.join(promotionAppPath, "locales/en")));
+        this.app.use("/promotion/locales/is/*splat", express.static(path.join(promotionAppPath, "locales/is")));
         // Land use game
         const landUseGamePath = path.join(baseDir, "land_use_game/dist");
         this.app.use("/land_use", express.static(landUseGamePath));
-        this.app.use("/land_use/*", express.static(landUseGamePath));
-        this.app.use("/land_use/locales/en/*", express.static(path.join(landUseGamePath, "locales/en")));
-        this.app.use("/land_use/locales/is/*", express.static(path.join(landUseGamePath, "locales/is")));
+        this.app.use("/land_use/*splat", express.static(landUseGamePath));
+        this.app.use("/land_use/locales/en/*splat", express.static(path.join(landUseGamePath, "locales/en")));
+        this.app.use("/land_use/locales/is/*splat", express.static(path.join(landUseGamePath, "locales/is")));
         this.app.use("/Assets", express.static(path.join(landUseGamePath, "Assets")));
         this.app.use("/ThirdParty", express.static(path.join(landUseGamePath, "ThirdParty")));
         this.app.use("/Widgets", express.static(path.join(landUseGamePath, "Widgets")));
@@ -606,12 +606,12 @@ export class YourPrioritiesApi {
         this.app.use("/domain", index);
         this.app.use("/community", index);
         this.app.use("/organization", index);
-        this.app.use("/agent_bundle/*", index);
+        this.app.use("/agent_bundle/*splat", index);
         this.app.use("/group", index);
         this.app.use("/post", index);
         this.app.use("/user", index);
         this.app.use("/admin", index);
-        this.app.use("/survey*", index);
+        this.app.use('/survey*splat', index);
         this.app.use("/api/domains", domains);
         this.app.use("/api/organizations", organizations);
         this.app.use("/api/communities", communities);

package/authorization.cjs

@@ -546,6 +546,10 @@ auth.entity("domain", function (req, done) {
     var match = req.originalUrl.match(/domains\/(\w+)/);
     if (!match)
         match = req.originalUrl.match(/videos\/(\w+)/);
+    if (!match)
+        match = req.originalUrl.match(/communities\/(\w+)/);
+    if (!match)
+        match = req.originalUrl.match(/groups\/(\w+)/);
     if (!match)
         match = req.originalUrl.match(/images\/(\w+)/);
     if (!match)

package/controllers/allOurIdeas.js

@@ -378,7 +378,8 @@ export class AllOurIdeasController {
         const questionParams = req.body;
         console.log(`in createQuestion: ${JSON.stringify(questionParams.ideas)}`);
         if (questionParams.ideas.length < 4) {
-            return res.status(400).json({ error: "Invalid input" });
+            res.status(400).json({ error: "Invalid input" });
+            return;
         }
         const requestBody = {
             name: questionParams.question,