json-object-editor 0.10.610 → 0.10.623

package/server/app-config.js

@@ -31,12 +31,13 @@ var apps = function(){
             title:'JOE Platform',
             info:'This is the master Data Model Management System (DMMS) admin page. It has access to all of your schemas and datasets.',
             description:'JOE is the Json Object Editor. The Platform app has access to all your schemas and datasets.',
-            plugins:['auth.js','formBuilder.js','reportbuilder.js','callbackTester.js','memberRegistry.js','awsConnect.js','notifier.js','calendar.js','inventory.js','money.js','plugin-utils.js','chatgpt.js','chatgpt-assistants.js','chatgpt-tools.js'],
+            plugins:['auth.js','formBuilder.js','reportbuilder.js','callbackTester.js','memberRegistry.js','awsConnect.js','notifier.js','calendar.js','inventory.js','money.js','plugin-utils.js','chatgpt.js','chatgpt-assistants.js','chatgpt-tools.js','chatgpt-responses.js'],
             collections:((default_schemas.concat(['schema','group',
                 'site','page','post','layout','block','include','event',
                 'project','board','task',
                 'transaction','budget','ledger',
                 'location','device','notification',
+                /*'ai_assistant','ai_conversation','ai_response','ai_tool','ai_prompt',*/
                 'visitor','question','form','submission','session','touchpoint','member']))).sort(),
                 dashboard:[
                     JOE.Apps.Cards.appHome({cssclass:'w3 h4'}),

package/server/fields/core.js

@@ -83,22 +83,7 @@ var fields = {
             return item.instructions_format;
         }
     },
-    ai_model:{
-        type: "select",
-        display: "Ai Model",
-        values: [
-            { value: "gpt-4o", name: "GPT-4o (Fast, 128k)" },
-            { value: "gpt-4.1", name: "GPT-4.1 (Strong, 1M)" },
-            { value: "gpt-4.1-mini", name: "4.1-mini (Cheap, 1M)" },
-            { value: "gpt-4.1-nano", name: "4.1-nano (Fastest, light tasks)" }
-          ],
-          tooltip:`Ai Model Guide -
-            GPT-4o is the default for fast, responsive tasks and supports up to 128k tokens. It’s ideal for short completions, summaries, and dynamic UI tools.
-            GPT-4.1 and 4.1-mini support a massive 1 million token context, making them perfect for large inputs like full business profiles, long strategy texts, and multi-object analysis.
-            4.1-mini is significantly cheaper than full 4.1, with great balance for most structured AI workflows.
-            4.1-nano is best for lightweight classification or routing logic where speed and cost matter more than depth.`,
-        default: "gpt-4o",
-      },
+
     template:{
         height:'600px',
         type:function(item){
@@ -300,6 +285,7 @@ var fields = {
         autocomplete_template:'<joe-title>${name} (.${filetype})</joe-title><joe-subtext>${info}</joe-subtext>'
 
     },
+/*    file_upload:{type:'uploader',allowmultiple:true, height:'300px',comment:'drag files here to upload', onConfirm:_joe.SERVER.Plugins.awsFileUpload,use_legacy:true},*/
     datasets:{type:'group',cols:2,
         comment:'which itemtypes(schemas) does this pertain to',values:function(){
             if(typeof(__collectionNames) != undefined){
@@ -529,7 +515,39 @@ var fields = {
             html += _joe.renderFieldListItem(item,temp,item.itemtype);
         });
         return html;
-    }}
+    }},
+    //AI Fields
+    ai_model:{
+        type: "select",
+        display: "Ai Model",
+        values: [
+            { value:"gpt-5.1", name: "GPT-5.1 (Strong, 128k)" },
+            { value:"gpt-5", name: "GPT-5 (Strong, 128K)" },
+            { value:"gpt-5-mini", name: "GPT-5-mini (Cheap, 1M)" },
+            { value:"gpt-5-nano", name: "GPT-5-nano (Fastest, light tasks)" },
+            { value: "gpt-4o", name: "GPT-4o (Fast, 128k)" },
+            { value: "gpt-4.1", name: "GPT-4.1 (Strong, 1M)" },
+            { value: "gpt-4.1-mini", name: "4.1-mini (Cheap, 1M)" },
+            { value: "gpt-4.1-nano", name: "4.1-nano (Fastest, light tasks)" }
+          ],
+          tooltip:`Ai Model Guide -
+            GPT-4o is the default for fast, responsive tasks and supports up to 128k tokens. It’s ideal for short completions, summaries, and dynamic UI tools.
+            GPT-4.1 and 4.1-mini support a massive 1 million token context, making them perfect for large inputs like full business profiles, long strategy texts, and multi-object analysis.
+            4.1-mini is significantly cheaper than full 4.1, with great balance for most structured AI workflows.
+            4.1-nano is best for lightweight classification or routing logic where speed and cost matter more than depth.`,
+        default: "gpt-4o",
+      },
+    objectChat:{
+        type:'button',
+        display:'Start Chat',
+        icon:'ai_assistant',
+        onclick:function(object){
+            if (!object || !object._id) return '';
+            return `_joe.Ai.spawnChatHelper('${object._id}');`;
+        },
+        
+    }
+
 };
 
 module.exports = fields;

package/server/modules/Server.js

@@ -169,6 +169,56 @@ server.get(JOE.webconfig.joepath+'_www/mcp-schemas.html',auth,function(req,res){
     res.sendFile(path.join(JOE.joedir,'_www','mcp-schemas.html'));
 });
 
+// AI Widget test page (Responses + assistants) – auth protected
+server.get(['/ai-widget-test.html', JOE.webconfig.joepath + 'ai-widget-test.html'], auth, function(req,res){
+    var assistantId = (req.query.assistant_id || req.query.assistant || '').trim();
+    if (!assistantId && JOE && JOE.Utils && JOE.Utils.Settings) {
+        try {
+            var settingObj = JOE.Utils.Settings('DEFAULT_AI_ASSISTANT', { object: true });
+            assistantId = (settingObj && settingObj.value) || '';
+        } catch(e) {
+            console.log('[ai-widget-test] error reading DEFAULT_AI_ASSISTANT:', e && e.message);
+        }
+    }
+    var joePath = (JOE && JOE.webconfig && JOE.webconfig.joepath) || '/JsonObjectEditor/';
+    var assistantAttr = assistantId ? ' ai_assistant_id="'+assistantId.replace(/"/g,'"')+'"' : '';
+
+    res.send(`<!doctype html>
+<html>
+<head>
+  <meta charset="utf-8">
+  <title>JOE AI Widget Test</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <style>
+    body{font-family:system-ui,-apple-system,Segoe UI,Roboto,Ubuntu,Cantarell,Noto Sans,sans-serif;margin:20px;background:#f3f4f6;}
+    h1{margin-top:0;}
+    .small{font-size:13px;color:#6b7280;margin-bottom:16px;}
+    .container{max-width:480px;margin:0 auto;background:#fff;border-radius:12px;box-shadow:0 4px 14px rgba(0,0,0,0.06);padding:16px;}
+    .meta{font-size:12px;color:#6b7280;margin-bottom:8px;}
+    code{background:#e5e7eb;border-radius:4px;padding:2px 4px;font-size:12px;}
+  </style>
+</head>
+<body>
+  <div id="mcp-nav"></div>
+  <script src="${joePath}_www/mcp-nav.js"></script>
+
+  <div class="container">
+    <h1>AI Widget Test</h1>
+    <div class="small">
+      This page mounts <code>&lt;joe-ai-widget&gt;</code> and sends messages through
+      <code>/API/plugin/chatgpt/widget*</code> using the OpenAI Responses API.
+      ${assistantId ? `Using <code>DEFAULT_AI_ASSISTANT</code> (ai_assistant_id=${assistantId}).` : 'No DEFAULT_AI_ASSISTANT is set; widget will use model defaults.'}
+      You can override the assistant via <code>?assistant_id=&lt;ai_assistant _id&gt;</code>.
+    </div>
+
+    <joe-ai-widget id="widget" title="JOE AI Assistant"${assistantAttr}></joe-ai-widget>
+  </div>
+
+  <script src="${joePath}js/joe-ai.js"></script>
+</body>
+</html>`);
+});
+
 server.use(JOE.webconfig.joepath,express.static(JOE.joedir));
 
 //USER

package/server/modules/Storage.js

@@ -101,7 +101,13 @@ function Storage(specs){
             try{
                 if(!data.joeUpdated){ data.joeUpdated = new Date().toISOString(); }
                 if(!data.created){
-                    var cachedBefore = (data && data._id && JOE && JOE.Cache && JOE.Cache.findByID) ? JOE.Cache.findByID(collection,data._id) : null;
+                    var cachedBefore = null;
+                    // Only use Cache.findByID when _id is a string; ObjectId instances can cause internal split() errors.
+                    if (data && data._id && typeof data._id === 'string' && JOE && JOE.Cache && JOE.Cache.findByID){
+                        try {
+                            cachedBefore = JOE.Cache.findByID(collection, data._id);
+                        } catch(__e){ cachedBefore = null; }
+                    }
                     if(!cachedBefore){ data.created = new Date().toISOString(); }
                 }
             }catch(_e){}

package/server/modules/Utils.js

@@ -74,7 +74,8 @@ var utils = function(){
                     module:"\x1b[33m",
                     white:"\x1b[37m",
                     black:'\x1b[30m',
-                    gray:'\x1b[90m'
+                    gray:'\x1b[90m',
+                    teal:'\x1b[36m'
                 };
                 var messagestring = '';
                 styles.map(function(i){

package/server/plugins/awsConnect.js

@@ -20,7 +20,8 @@ const s3 = new S3Client({
     } : undefined
 });
 
-var ACL = data.ACL || 'public-read';
+// Default to public-read unless explicitly overridden; allows legacy behavior to keep working
+var ACL = (data.hasOwnProperty('ACL') ? data.ACL : 'public-read');
 var Bucket = JOE.Cache.settings.AWS_BUCKETNAME;
 var file = data.file || 'body';
 // Create a bucket using bound parameters and put something in it.
@@ -35,7 +36,8 @@ if(data.base64){
     var buf = Buffer.from(data.base64.replace(/^data:[a-zA-Z0-9\_\-]*\/[a-zA-Z0-9\_\-]*;base64,/, ""),'base64');
     s3Params.Body = buf;
     s3Params.ContentEncoding = 'base64';
-    s3Params.ContentType = data.extension || 'image/jpeg';
+    // Prefer explicit contentType; fall back to extension or a safe default
+    s3Params.ContentType = data.contentType || data.extension || 'application/octet-stream';
     
 }
 
@@ -51,17 +53,41 @@ var response = {
     Key:Key,
     bucket:Bucket
 }
-    s3Params.ACL = ACL || 'public-read';
+    // Early validation
+    if(!Bucket){
+        return res.status(400).send({ error:'AWS bucket is not configured (settings.AWS_BUCKETNAME).' });
+    }
+    if(!config || !config.region){
+        return res.status(400).send({ error:'AWS S3 region is missing. Set settings.AWS_S3CONFIG.region.' });
+    }
+
+    // Only include ACL if requested (string and not empty)
+    if(ACL){
+        s3Params.ACL = ACL;
+    }
+
     s3.send(new PutObjectCommand(s3Params))
         .then(function(data){
+            // Construct canonical URL from region + bucket
+            var region = config.region;
+            var url = 'https://'+Bucket+'.s3.'+region+'.amazonaws.com/'+Key;
             response.data = data;
-            res.send(response);
+            response.url = url;
+            res.status(200).send(response);
             console.log("Successfully uploaded data to "+Key);
         })
         .catch(function(err){
-            response.error = err;
-            res.send(response);
+            var code = (err && (err.Code || err.name)) || 'UploadError';
+            var message = (err && (err.message || String(err))) || 'Upload failed';
+            // Clear, actionable error when ACLs are disabled on bucket
+            if(code === 'AccessControlListNotSupported'){
+                return res.status(400).send({ 
+                    error: 'Bucket has ACLs disabled (Object Ownership enforced). Remove ACL or switch to presigned/proxy access.', 
+                    code: code 
+                });
+            }
             console.log("Error uploading data: ", err);
+            res.status(500).send({ error: message, code: code });
         });
     return {use_callback:true};
 

package/server/plugins/chatgpt-assistants.js

@@ -1,6 +1,7 @@
-
-const { run } = require("googleapis/build/src/apis/run");
+const savedArrayDelete = Array.prototype.delete;
+delete Array.prototype.delete;
 const OpenAI = require("openai");
+if (savedArrayDelete) Array.prototype.delete = savedArrayDelete;
 
 function ChatGPTAssistants() {
   const self = this;
@@ -67,7 +68,6 @@ function ChatGPTAssistants() {
   }
   this.syncAssistantToOpenAI = async function(data, req, res) {
     const openai = newClient();
-  
     try {
       coloredLog("🔄 Starting syncAssistantToOpenAI");
   

package/server/plugins/chatgpt-responses.js

@@ -0,0 +1,45 @@
+const OpenAI = require("openai");
+
+function ChatGPTResponses() {
+	const self = this;
+
+	function log(prefix, message, data) {
+		const p = JOE.Utils.color('[chatgpt-responses]', 'plugin', false);
+		console.log(p, prefix, message || '', (data !== undefined ? data : ''));
+	}
+
+	this.default = function (data, req, res) {
+		try {
+			return {
+				success: true,
+				message: 'chatgpt-responses proxy plugin ready',
+				params: req.params,
+				query: req.query,
+				body: req.body
+			};
+		} catch (e) {
+			return { errors: 'plugin error: ' + e, failedat: 'plugin' };
+		}
+	};
+
+	// Thin proxy to chatgpt.autofill to avoid duplication
+	this.autofill = async function (data, req, res) {
+		try {
+			const base = JOE.Apps && JOE.Apps.plugins && JOE.Apps.plugins['chatgpt'];
+			if (!base || !base.autofill) {
+				return { success: false, error: 'chatgpt.autofill not available' };
+			}
+			const result = await base.autofill(data, req, res);
+			return result;
+		} catch (e) {
+			log('error', e && e.message);
+			return { success: false, error: e && e.message || 'Unknown error' };
+		}
+	};
+
+	return self;
+}
+
+module.exports = new ChatGPTResponses();
+
+