@yrpri/api 9.0.121 → 9.0.123

package/controllers/domains.cjs

@@ -808,6 +808,7 @@ function updateDomainProperties(domain, req) {
     domain.set('configuration.ga4Tag', (req.body.ga4Tag && req.body.ga4Tag !== "") ? req.body.ga4Tag : null);
     domain.set('configuration.useLoginOnDomainIfNotLoggedIn', truthValueFromBody(req.body.useLoginOnDomainIfNotLoggedIn));
     domain.set('configuration.forceElectronicIds', truthValueFromBody(req.body.forceElectronicIds));
+    domain.set('configuration.doNotCreateElectronicIdUsersAutomatically', truthValueFromBody(req.body.doNotCreateElectronicIdUsersAutomatically));
     if (req.body.google_analytics_code && req.body.google_analytics_code !== "") {
         domain.google_analytics_code = req.body.google_analytics_code;
     }

package/models/user.cjs

@@ -114,7 +114,7 @@ module.exports = (sequelize, DataTypes) => {
     User.serializeSamlUser = (profile, req, callback) => {
         log.info("Serialize SAML user", { context: 'serializeSamlUser', profile: profile });
         if (profile.UserSSN) {
-            sequelize.models.User.serializeIslandIsSamlUser(profile, callback);
+            sequelize.models.User.serializeIslandIsSamlUser(profile, req, callback);
         }
         else if (profile["urn:mynj:userCode"] || profile.issuer === 'https://my.state.nj.us/idp/shibboleth') {
             sequelize.models.User.serializeMyNJSamlUser(profile, req, callback);
@@ -188,6 +188,11 @@ module.exports = (sequelize, DataTypes) => {
             },
             (seriesCallback) => {
                 if (!user) {
+                    if (req.ypDomain.configuration &&
+                        req.ypDomain.configuration.doNotCreateElectronicIdUsersAutomatically) {
+                        seriesCallback("customError");
+                        return;
+                    }
                     sequelize.models.User.create({
                         ssn: profile["urn:mynj:userCode"],
                         name: profile.FirstName + ' ' + profile.LastName,
@@ -227,7 +232,7 @@ module.exports = (sequelize, DataTypes) => {
             }
         });
     };
-    User.serializeIslandIsSamlUser = (profile, callback) => {
+    User.serializeIslandIsSamlUser = (profile, req, callback) => {
         log.info("User Serialized In Serialize IslandIs SAML User", { context: 'serializeSamlUser', profile: profile });
         let user;
         async.series([
@@ -252,6 +257,11 @@ module.exports = (sequelize, DataTypes) => {
             },
             (seriesCallback) => {
                 if (!user) {
+                    if (req.ypDomain.configuration &&
+                        req.ypDomain.configuration.doNotCreateElectronicIdUsersAutomatically) {
+                        seriesCallback("customError");
+                        return;
+                    }
                     sequelize.models.User.create({
                         ssn: profile.UserSSN,
                         name: profile.Name,
@@ -309,6 +319,11 @@ module.exports = (sequelize, DataTypes) => {
             },
             (seriesCallback) => {
                 if (!user) {
+                    if (req.ypDomain.configuration &&
+                        req.ypDomain.configuration.doNotCreateElectronicIdUsersAutomatically) {
+                        seriesCallback("customError");
+                        return;
+                    }
                     sequelize.models.User.create({
                         ssn: profile.nationalRegisterId,
                         name: profile.name,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yrpri/api",
-  "version": "9.0.121",
+  "version": "9.0.123",
   "license": "MIT",
   "author": "Robert Bjarnason & Citizens Foundation",
   "repository": {

package/scripts/agents/generateAgentWorkflowTemplateFromAgentClass.d.ts

@@ -0,0 +1 @@
+export {};

package/scripts/agents/generateAgentWorkflowTemplateFromAgentClass.js

@@ -0,0 +1,86 @@
+import { PsAgentClass, PsAgent, PsAiModel } from "@policysynth/agents/dbModels/index.js";
+import models from "../../models/index.cjs";
+import { NewAiModelSetup } from "../../agents/managers/newAiModelSetup.js";
+(async () => {
+    const [domainIdArg, agentClassIdArg] = process.argv.slice(2);
+    if (!domainIdArg || !agentClassIdArg) {
+        console.error("Usage: ts-node generateAgentWorkflowTemplateFromAgentClass.ts <domainId> <psAgentClassId>");
+        process.exit(1);
+    }
+    const domainId = Number(domainIdArg);
+    const agentClassId = Number(agentClassIdArg);
+    if (isNaN(domainId) || isNaN(agentClassId)) {
+        console.error("Both domainId and psAgentClassId must be valid numbers");
+        process.exit(1);
+    }
+    try {
+        await NewAiModelSetup.initializeModels();
+        const domain = await models.Domain.findByPk(domainId);
+        if (!domain) {
+            throw new Error(`Domain ${domainId} not found`);
+        }
+        // Create Community
+        const community = await models.Community.create({
+            domain_id: domainId,
+            name: `Agent Workflow Template ${Date.now()}`,
+            hostname: `agent-workflow-${Date.now()}`,
+            access: 1,
+            user_id: 1,
+            ip_address: "127.0.0.1",
+            user_agent: "generateAgentWorkflowTemplateFromAgentClass.ts",
+            configuration: {},
+        });
+        // Create Workflow Group
+        const group = await models.Group.create({
+            community_id: community.id,
+            name: "Agent Workflow",
+            access: 0,
+            user_id: 1,
+            ip_address: "127.0.0.1",
+            user_agent: "generateAgentWorkflowTemplateFromAgentClass.ts",
+            configuration: { groupType: 3, agents: {} },
+        });
+        // Create PsAgent from class
+        const agentClass = await PsAgentClass.findByPk(agentClassId);
+        if (!agentClass) {
+            throw new Error(`PsAgentClass ${agentClassId} not found`);
+        }
+        const psAgent = await PsAgent.create({
+            user_id: agentClass.user_id,
+            class_id: agentClass.id,
+            group_id: group.id,
+            configuration: {},
+        });
+        // Add Gemini 2.5 Pro Preview 2 model
+        const geminiReasoning = await PsAiModel.findOne({
+            where: { name: "Gemini 2.5 Pro Preview 2" },
+        });
+        if (geminiReasoning) {
+            await psAgent.addAiModel(geminiReasoning);
+        }
+        else {
+            throw new Error("Gemini 2.5 Pro Preview 2 model not found");
+        }
+        // Add Gemini 2.0 Flash model
+        const geminiFlash = await PsAiModel.findOne({
+            where: { name: "Gemini 2.0 Flash" },
+        });
+        if (geminiFlash) {
+            await psAgent.addAiModel(geminiFlash);
+        }
+        else {
+            throw new Error("Gemini 2.0 Flash model not found");
+        }
+        // Update group configuration with top level agent id
+        group.configuration.agents = { topLevelAgentId: psAgent.id };
+        group.changed("configuration", true);
+        await group.save();
+        console.log(`Created community ${community.id}, group ${group.id}, agent ${psAgent.id}`);
+    }
+    catch (error) {
+        console.error(error);
+    }
+    finally {
+        await models.sequelize.close();
+    }
+})();

package/scripts/domains/createDomain.d.ts

@@ -0,0 +1 @@
+export {};

package/scripts/domains/createDomain.js

@@ -0,0 +1,31 @@
+import models from '../../models/index.cjs';
+(async () => {
+    try {
+        const [userId, domainName, name] = process.argv.slice(2);
+        if (!domainName || !name) {
+            console.log('Usage: node createDomain.js <user_id> <domain_name> "<name>"');
+            process.exit(1);
+        }
+        const existing = await models.Domain.findOne({ where: { domain_name: domainName } });
+        if (existing) {
+            console.error(`Domain with domain_name ${domainName} already exists`);
+            process.exit(1);
+        }
+        const domain = await models.Domain.create({
+            domain_name: domainName,
+            name,
+            access: 1,
+            user_id: parseInt(userId),
+            ip_address: '127.0.0.1',
+            user_agent: 'cli-script',
+            default_locale: 'en',
+            configuration: {}
+        });
+        console.log(`Created domain ${domain.name} with id ${domain.id}`);
+        process.exit(0);
+    }
+    catch (err) {
+        console.error(err);
+        process.exit(1);
+    }
+})();