npm - json-object-editor - Versions diffs - 0.10.444 → 0.10.503 - Mend

json-object-editor 0.10.444 → 0.10.503

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (8) hide show

package/CHANGELOG.md CHANGED Viewed

@@ -1,5 +1,37 @@
 ## CHANGELOG
+### 0.10.500
+	500 - MCP integration (initial)
+	- MCP core module with JSON-RPC 2.0 endpoint (/mcp) protected by auth
+	- Manifest available at /.well-known/mcp/manifest.json for tool discovery
+	- Tools: listSchemas, getSchema, getObject, getObjectsByIds, queryObjects, searchCache, saveObject
+	- Tools mapped to real JOE APIs (Schemas, Storage, Cache) with sensitive-field sanitization
+	- Read-path prefers Cache for speed; saveObject uses Storage.save (events/history/socket emit)
+	- Adopted module init pattern: MCP.init() attaches routes via init.js; removed direct Server.js wiring
+	502 - MCP refinements + tooling
+	- Unified search tool; deprecated older object/query tools in manifest
+	- getObject flattens by default; optional depth param
+	- New hydrate tool returns core fields (from server/fields/core.js), all schemas, statuses, and tags
+	- Test pages: mcp-test updated; mcp-export generates Actions/Assistants configs
+	- Server serves JOE _www as root fallback so test pages are easy to reach
+	- Assistants plugin: support {type:"mcp", url} in tools → imports MCP manifest; dev TLS bypass option; improved error logs
+	503 - Hydrate simplification & manifest instance info
+	- Hydrate takes no params; always returns core fields, schemas, statuses, tags
+	- Hydrate includes full core field definitions from server/fields/core.js (not just names)
+	- Manifest now includes { joe: { name, version, hostname } }; mcp-test shows this
+### 0.10.500
+	500 - MCP integration (initial)
+	- MCP core module with JSON-RPC 2.0 endpoint (/mcp) protected by auth
+	- Manifest available at /.well-known/mcp/manifest.json for tool discovery
+	- Tools: listSchemas, getSchema, getObject, getObjectsByIds, queryObjects, searchCache, saveObject
+	- Tools mapped to real JOE APIs (Schemas, Storage, Cache) with sensitive-field sanitization
+	- Read-path prefers Cache for speed; saveObject uses Storage.save (events/history/socket emit)
+	- Adopted module init pattern: MCP.init() attaches routes via init.js; removed direct Server.js wiring
+	- Basics for local testing (auth + example payloads) to be added to README
 ### 0.10.400
 	443 - added npm build support
 	442 - engagements (alpha)

package/_www/mcp-export.html ADDED Viewed

@@ -0,0 +1,186 @@
+<!doctype html>
+<html>
+<head>
+	<meta charset="utf-8">
+	<title>JOE MCP → Assistant Config Export</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;}
+		label{display:block;margin:8px 0 4px}
+		input,button,textarea{font-size:14px}
+		input[type=text]{min-width:320px}
+		textarea{width:100%;height:200px;font-family:ui-monospace,Menlo,Consolas,monospace}
+		pre{background:#f6f8fa;border:1px solid #e1e4e8;padding:10px;overflow:auto}
+		.grid{display:grid;grid-template-columns:1fr;gap:18px}
+		.row{display:flex;gap:10px;align-items:center;flex-wrap:wrap}
+		.small{font-size:12px;color:#666}
+		.good{color:#0a7d00}.bad{color:#b00020}
+		code{background:#f6f8fa;padding:2px 4px;border-radius:3px}
+	</style>
+</head>
+<body>
+	<h1>JOE MCP → Assistant Config Export</h1>
+	<div class="small">Generate copy/paste config for Custom GPT Actions (OpenAPI) and Assistants (tools array).</div>
+	<div class="grid">
+		<section>
+			<h3>1) Server</h3>
+			<div class="row">
+				<label for="base">Base URL</label>
+				<input id="base" type="text" placeholder="https://example.com" />
+			</div>
+			<div class="row">
+				<label for="manifestPath">Manifest path</label>
+				<input id="manifestPath" type="text" value="/.well-known/mcp/manifest.json" />
+			</div>
+			<div class="row">
+				<label for="auth">Authorization header (optional)</label>
+				<input id="auth" type="text" placeholder="Basic BASE64(user:pass)" />
+			</div>
+			<div class="row">
+				<button id="load">Load manifest</button>
+				<span id="status" class="small"></span>
+			</div>
+			<pre id="manifestOut" style="display:none"></pre>
+		</section>
+		<section>
+			<h3>2) Custom GPT Actions (OpenAPI 3.1)</h3>
+			<div class="small">Paste this schema into GPT Builder → Actions → Import from text.</div>
+			<textarea id="openapi" readonly></textarea>
+		</section>
+		<section>
+			<h3>3) Assistants API tools (functions array)</h3>
+			<div class="small">Use this tools JSON in code when creating/updating an Assistant.</div>
+			<textarea id="tools" readonly></textarea>
+		</section>
+		<section>
+			<h3>4) JSON-RPC request template</h3>
+			<div class="small">When the Assistant calls a tool, POST this body to <code>/mcp</code>.</div>
+			<pre>{
+  "jsonrpc": "2.0",
+  "id": "<opaque-id>",
+  "method": "<toolName>",
+  "params": { /* per-tool params */ }
+}</pre>
+		</section>
+	</div>
+	<script>
+(function(){
+  const $ = (id)=>document.getElementById(id);
+  const base = $('base');
+  const manifestPath = $('manifestPath');
+  const auth = $('auth');
+  const loadBtn = $('load');
+  const status = $('status');
+  const openapiEl = $('openapi');
+  const toolsEl = $('tools');
+  const manifestOut = $('manifestOut');
+  base.value = base.value || (location.origin);
+  function setStatus(msg, ok){
+    status.textContent = msg||'';
+    status.className = 'small ' + (ok===true?'good': ok===false?'bad':'');
+  }
+  function buildAssistantsTools(manifest){
+    const tools = (manifest.tools||[]).map(t=>({
+      type: 'function',
+      function: {
+        name: t.name,
+        description: t.description||'',
+        parameters: t.params || { type:'object' }
+      }
+    }));
+    return tools;
+  }
+  function buildOpenAPI(manifest, serverUrl){
+    const methodEnum = (manifest.tools||[]).map(t=>t.name);
+    const oneOf = (manifest.tools||[]).map(t=>({
+      type:'object',
+      description: t.description || t.name,
+      required: [],
+      properties: t.params && t.params.properties ? t.params.properties : {},
+    }));
+    const schema = {
+      openapi: '3.1.0',
+      info: { title: 'JOE MCP Bridge', version: '1.0.0' },
+      servers: [{ url: serverUrl.replace(/\/$/,'') }],
+      paths: {
+        '/mcp': {
+          post: {
+            operationId: 'mcpCall',
+            summary: 'Call a JOE MCP tool',
+            description: 'Use one of: ' + methodEnum.join(', '),
+            requestBody: {
+              required: true,
+              content: {
+                'application/json': {
+                  schema: {
+                    type: 'object',
+                    required: ['jsonrpc','id','method','params'],
+                    properties: {
+                      jsonrpc: { type:'string', const:'2.0' },
+                      id: { type:'string' },
+                      method: { type:'string', enum: methodEnum },
+                      params: { oneOf: oneOf.length? oneOf : [{ type:'object' }] }
+                    }
+                  }
+                }
+              }
+            },
+            responses: { '200': { description:'OK' } }
+          }
+        }
+      }
+    };
+    return schema;
+  }
+  async function fetchJSON(url){
+    const headers = {};
+    if(auth.value){ headers['Authorization'] = auth.value; }
+    const res = await fetch(url, { headers });
+    if(!res.ok){
+      throw new Error('HTTP '+res.status+' '+(await res.text()));
+    }
+    return res.json();
+  }
+  loadBtn.onclick = async function(){
+    try{
+      setStatus('Loading...', null);
+      openapiEl.value = '';
+      toolsEl.value = '';
+      manifestOut.style.display='none';
+      const url = base.value.replace(/\/$/,'') + manifestPath.value;
+      const manifest = await fetchJSON(url);
+      manifestOut.style.display='block';
+      manifestOut.textContent = JSON.stringify(manifest, null, 2);
+      const tools = buildAssistantsTools(manifest);
+      toolsEl.value = JSON.stringify(tools, null, 2);
+      const openapi = buildOpenAPI(manifest, base.value);
+      openapiEl.value = JSON.stringify(openapi, null, 2);
+      setStatus('Manifest loaded. Config generated.', true);
+    }catch(e){
+      setStatus(e.message||String(e), false);
+    }
+  };
+  // Auto-load
+  setTimeout(()=>loadBtn.click(), 50);
+})();
+	</script>
+</body>
+</html>

package/_www/mcp-test.html ADDED Viewed

@@ -0,0 +1,146 @@
+<!doctype html>
+<html>
+<head>
+	<meta charset="utf-8">
+	<title>JOE MCP 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;}
+		label{display:block;margin:8px 0 4px}
+		select, input, textarea, button{font-size:14px}
+		textarea{width:100%;height:160px;font-family:ui-monospace,Menlo,Consolas,monospace}
+		pre{background:#f6f8fa;border:1px solid #e1e4e8;padding:10px;overflow:auto}
+		.row{display:flex;gap:12px;align-items:center;flex-wrap:wrap}
+		.small{font-size:12px;color:#666}
+		.bad{color:#b00020}
+		.good{color:#0a7d00}
+	</style>
+</head>
+<body>
+    <h1>JOE MCP Test</h1>
+    <div class="small">Use this page to discover tools and call the JSON-RPC endpoint.</div>
+    <pre id="instanceInfo" class="small">Loading instance info…</pre>
+	<h3>Manifest</h3>
+	<div class="row">
+		<label for="base">Base URL</label>
+		<input id="base" value="" placeholder="http://localhost:{{PORT}}" style="min-width:280px"/>
+		<button id="loadManifest">Load manifest</button>
+		<span id="status" class="small"></span>
+	</div>
+	<label for="tool">Tools</label>
+	<select id="tool"></select>
+	<pre id="toolInfo"></pre>
+	<h3>Call JSON-RPC</h3>
+	<label for="params">Params (JSON)</label>
+	<textarea id="params">{}</textarea>
+	<div class="row">
+		<button id="call">POST /mcp</button>
+		<span id="callStatus" class="small"></span>
+	</div>
+	<pre id="result"></pre>
+	<script>
+	(function(){
+		const $ = (id)=>document.getElementById(id);
+		const base = $('base');
+		const loadBtn = $('loadManifest');
+		const status = $('status');
+		const toolSel = $('tool');
+		const toolInfo = $('toolInfo');
+		const params = $('params');
+		const callBtn = $('call');
+		const callStatus = $('callStatus');
+		const result = $('result');
+		// Try to infer base from window location
+		base.value = base.value || (location.origin);
+		let manifest = null;
+		let idCounter = 1;
+		function setStatus(el, msg, ok){
+			el.textContent = msg || '';
+			el.className = 'small ' + (ok===true?'good': ok===false?'bad':'');
+		}
+		async function fetchJSON(url, opts){
+			const res = await fetch(url, opts);
+			const ct = res.headers.get('content-type')||'';
+			const isJSON = ct.includes('application/json');
+			if(!res.ok){
+				let detail = isJSON ? await res.json().catch(()=>({})) : await res.text();
+				throw new Error('HTTP '+res.status+': '+(isJSON?JSON.stringify(detail):detail));
+			}
+			return isJSON ? res.json() : res.text();
+		}
+		loadBtn.onclick = async function(){
+			setStatus(status, 'Loading...', null);
+			toolSel.innerHTML = '';
+			toolInfo.textContent='';
+			try{
+				const url = base.value.replace(/\/$/,'') + '/.well-known/mcp/manifest.json';
+				manifest = await fetchJSON(url);
+                // Instance info
+                if (manifest.joe){
+                    $('instanceInfo').textContent = `Name: ${manifest.joe.name} | Version: ${manifest.joe.version} | Host: ${manifest.joe.hostname}`;
+                }
+                (manifest.tools||[]).forEach(t=>{
+					const opt=document.createElement('option');
+					opt.value=t.name; opt.textContent=t.name;
+					toolSel.appendChild(opt);
+				});
+				if((manifest.tools||[]).length){
+					toolSel.selectedIndex=0; renderToolInfo();
+				}
+				setStatus(status, 'Manifest loaded', true);
+			}catch(e){
+				setStatus(status, e.message||String(e), false);
+			}
+		};
+		function renderToolInfo(){
+			const name = toolSel.value;
+			const tool = (manifest.tools||[]).find(t=>t.name===name);
+			toolInfo.textContent = tool ? JSON.stringify(tool, null, 2) : '';
+			// Prefill common params for convenience
+			if(tool && tool.params){
+				params.value = JSON.stringify(Object.fromEntries(Object.keys(tool.params.properties||{}).map(k=>[k, null])), null, 2);
+			}
+			// Hydrate presets UI
+			if (name === 'hydrate') {
+				params.value = JSON.stringify({}, null, 2);
+			}
+		}
+		toolSel.onchange = renderToolInfo;
+		callBtn.onclick = async function(){
+			setStatus(callStatus, 'Calling...', null);
+			result.textContent='';
+			try{
+				const url = base.value.replace(/\/$/,'') + '/mcp';
+				let p = {};
+				try{ p = params.value ? JSON.parse(params.value) : {}; }catch(e){ throw new Error('Invalid JSON in params'); }
+				const body = {
+					jsonrpc: '2.0',
+					id: String(idCounter++),
+					method: toolSel.value,
+					params: p
+				};
+				const resp = await fetchJSON(url, { method:'POST', headers:{'Content-Type':'application/json'}, body: JSON.stringify(body)});
+				result.textContent = JSON.stringify(resp, null, 2);
+				setStatus(callStatus, 'OK', true);
+			}catch(e){
+				setStatus(callStatus, e.message||String(e), false);
+			}
+		};
+		// Auto-load manifest on open
+		setTimeout(()=>loadBtn.click(), 50);
+		})();
+	</script>
+</body>
+</html>

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "json-object-editor",
-  "version": "0.10.444",
+  "version": "0.10.503",
   "description": "JOE the Json Object Editor | Platform Edition",
   "main": "app.js",
   "scripts": {
@@ -38,14 +38,13 @@
     "craydent": "^0.8.9",
     "express": "^4.16.4",
     "googleapis": "^149.0.0",
-    "got": "^12.6.0",
     "jwt-decode": "^2.2.0",
     "mailgun": "^0.5.0",
     "mongojs": "^2.3.0",
     "mysql": "^2.16.0",
     "nodemailer": "^2.7.2",
     "nodemailer-ses-transport": "^1.4.0",
-    "openai": "^5.22.0",
+    "openai": "^5.23.2",
     "opener": "^1.4.3",
     "pem": "^1.13.2",
     "plaid": "^13.1.0",

package/readme.md CHANGED Viewed

@@ -5,6 +5,119 @@ JOE is software that allows you to manage data models via JSON objects. There ar
+## Architecture & Mental Model (Server)
+- Global JOE
+  - Created in `server/init.js`; exposes subsystems like `JOE.Utils`, `JOE.Schemas`, `JOE.Storage`, `JOE.Mongo`/`JOE.MySQL`, `JOE.Cache`, `JOE.Apps`, `JOE.Server` (Express), `JOE.Sites`, `JOE.io` (Socket), and `JOE.auth`.
+- Init pattern
+  - Modules can optionally export `init()`; `init.js` loads/watches modules and calls `init()` after `JOE.Server` is ready. This enables hot-reload and keeps `Server.js` thin.
+- Schemas & events
+  - `JOE.Schemas` loads from `server/schemas/` and app schema dir into `JOE.Schemas.schema` with names in `JOE.Schemas.schemaList`. Raw copies live in `JOE.Schemas.raw_schemas` for event hooks.
+  - `JOE.Storage.save()` triggers schema events (`create`, `save`, `status`, `delete`) via `JOE.Schemas.events()` and writes history documents to `_history`.
+- Storage & cache
+  - `JOE.Storage.load(collection, query, cb)` chooses backend per schema `storage.type` (`mongo`, `mysql`, `file`, `api`), with Mongo/file fallback.
+  - `JOE.Storage.save(item, collection, cb, { user, history })` emits `item_updated` to sockets, records history, and fires events.
+  - `JOE.Cache.update(cb, collections)` populates `JOE.Data`, flattens a `list`, and builds `lookup`. Use `JOE.Cache.findByID(collection, idOrCsv)` for fast lookups; `JOE.Cache.search(query)` for in-memory filtering.
+- Auth
+  - `JOE.auth` middleware checks cookie token or Basic Auth; many API routes (and `/mcp`) are protected.
+- Shorthand `$J`
+  - Server and client convenience: `$J.get(_id)`, `$J.search(query)`, `$J.schema(name)`.
+  - On server, provided by `server/modules/UniversalShorthand.js` and assigned to `global.$J` in `init.js`.
+- MCP overview
+  - Manifest: `/.well-known/mcp/manifest.json`; JSON-RPC: `POST /mcp` (auth-protected). Tools map to real JOE APIs (`Schemas`, `Storage`, `Cache`) and sanitize sensitive fields.
+## MCP routes and local testing
+- Endpoints
+  - Manifest (public): `GET /.well-known/mcp/manifest.json`
+  - JSON-RPC (auth): `POST /mcp`
+- Auth
+  - If users exist, `POST /mcp` requires cookie or Basic Auth (same as other APIs). If no users configured, it is effectively open.
+- Test page
+  - JOE ships a simple tester at `/_www/mcp-test.html` inside the package.
+  - Access via JOE path: `http://localhost:<PORT>/JsonObjectEditor/_www/mcp-test.html`
+  - If your host app serves its own `_www`, the tester can also be available at the root (fallback) if running with the updated server that mounts JOE’s `_www` as a secondary static directory. Then: `http://localhost:<PORT>/mcp-test.html`
+- Tools
+  - `listSchemas(name?)`, `getSchema(name)`
+  - `getObject(_id, schema?)` (flattens by default; supports `depth` override)
+  - `search` (preferred): unified tool for cache and storage
+    - Params: `{ schema?, query?, ids?, source?: 'cache'|'storage', limit?, flatten?, depth? }`
+    - Defaults to cache across all collections; add `schema` to filter; set `source:"storage"` to query a specific schema in the DB.
+  - `saveObject({ object })`
+- Quick tests (PowerShell)
+  - Prepare headers if using Basic Auth:
+    ```powershell
+    $pair = "user:pass"; $b64 = [Convert]::ToBase64String([Text.Encoding]::ASCII.GetBytes($pair))
+    $h = @{ Authorization = "Basic $b64"; "Content-Type" = "application/json" }
+    $base = "http://localhost:<PORT>"
+    ```
+  - Manifest:
+    ```powershell
+    Invoke-RestMethod "$base/.well-known/mcp/manifest.json"
+    ```
+  - listSchemas:
+    ```powershell
+    $body = @{ jsonrpc="2.0"; id="1"; method="listSchemas"; params=@{} } | ConvertTo-Json -Depth 6
+    Invoke-RestMethod -Method Post -Uri "$base/mcp" -Headers $h -Body $body
+    ```
+  - getSchema:
+    ```powershell
+    $body = @{ jsonrpc="2.0"; id="2"; method="getSchema"; params=@{ name="<schemaName>" } } | ConvertTo-Json -Depth 6
+    Invoke-RestMethod -Method Post -Uri "$base/mcp" -Headers $h -Body $body
+    ```
+  - search (cache default):
+    ```powershell
+    $body = @{ jsonrpc="2.0"; id="3"; method="search"; params=@{ query=@{ itemtype="<schemaName>" }; limit=10 } } | ConvertTo-Json -Depth 10
+    Invoke-RestMethod -Method Post -Uri "$base/mcp" -Headers $h -Body $body
+    ```
+  - search (storage):
+    ```powershell
+    $body = @{ jsonrpc="2.0"; id="4"; method="search"; params=@{ schema="<schemaName>"; source="storage"; query=@{ }; limit=10 } } | ConvertTo-Json -Depth 10
+    Invoke-RestMethod -Method Post -Uri "$base/mcp" -Headers $h -Body $body
+    ```
+  - search (ids + flatten):
+    ```powershell
+    $body = @{ jsonrpc="2.0"; id="5"; method="search"; params=@{ schema="<schemaName>"; ids=@("<id1>","<id2>"); flatten=$true; depth=2 } } | ConvertTo-Json -Depth 10
+    Invoke-RestMethod -Method Post -Uri "$base/mcp" -Headers $h -Body $body
+    ```
+  - saveObject:
+    ```powershell
+    $object = @{ itemtype="<schemaName>"; name="Test via MCP" }
+    $body = @{ jsonrpc="2.0"; id="4"; method="saveObject"; params=@{ object=$object } } | ConvertTo-Json -Depth 10
+    Invoke-RestMethod -Method Post -Uri "$base/mcp" -Headers $h -Body $body
+    ```
+- Quick tests (curl)
+  - Manifest:
+    ```bash
+    curl -s http://localhost:<PORT>/.well-known/mcp/manifest.json | jq
+    ```
+  - listSchemas:
+  - search (cache):
+    ```bash
+    curl -s -X POST http://localhost:<PORT>/mcp \
+      -H 'Content-Type: application/json' \
+      -d '{"jsonrpc":"2.0","id":"3","method":"search","params":{"query":{"itemtype":"<schemaName>"},"limit":10}}' | jq
+    ```
+  - search (storage):
+    ```bash
+    curl -s -X POST http://localhost:<PORT>/mcp \
+      -H 'Content-Type: application/json' \
+      -d '{"jsonrpc":"2.0","id":"4","method":"search","params":{"schema":"<schemaName>","source":"storage","query":{},"limit":10}}' | jq
+    ```
+    ```bash
+    curl -s -X POST http://localhost:<PORT>/mcp \
+      -H 'Content-Type: application/json' \
+      -d '{"jsonrpc":"2.0","id":"1","method":"listSchemas","params":{}}' | jq
+    ```
+- Troubleshooting
+  - If you see a payload like `{ originalURL: "/...", site: "no site found" }`, the request hit the Sites catch-all. Ensure MCP routes are initialized before Sites (handled by default in `server/init.js` via `MCP.init()`), and use the correct URL: `/.well-known/mcp/manifest.json` or `/mcp`.
 ## SERVER/PLATFORM mode
 	check port 2099
 	/JOE/

package/server/init.js CHANGED Viewed

@@ -97,6 +97,13 @@ var app = function(config){
         global.$J = require('./modules/UniversalShorthand.js');
         function initServers(){
             JOE.Server = require('./modules/Server.js');
+            // Attach MCP routes before Sites catch-all
+            try {
+                const MCP = require('./modules/MCP.js');
+                if (MCP && MCP.init) MCP.init();
+            } catch (e) {
+                console.log('[MCP] attach error:', e && e.message);
+            }
             JOE.Sites = require('./modules/Sites.js');
             JOE.io = require('./modules/Socket.js');

package/server/modules/MCP.js ADDED Viewed

@@ -0,0 +1,339 @@
+// modules/MCP.js
+/**
+ * Model Context Protocol (MCP) core module for JOE.
+ * This module provides a JSON-RPC 2.0 compatible interface to JOE objects and schemas.
+ * Agents (like OpenAI Assistants) can discover and call structured tools via manifest + POST.
+ */
+const MCP = {};
+const { Storage, Schemas } = global.JOE; // Adjust as needed based on how your modules are wired
+// Internal helpers
+function loadFromStorage(collection, query) {
+  return new Promise((resolve, reject) => {
+    try {
+      Storage.load(collection, query || {}, function(err, results){
+        if (err) return reject(err);
+        resolve(results || []);
+      });
+    } catch (e) {
+      reject(e);
+    }
+  });
+}
+function sanitizeItems(items) {
+  try {
+    const arr = Array.isArray(items) ? items : [items];
+    return arr.map(i => {
+      if (!i || typeof i !== 'object') return i;
+      const copy = JSON.parse(JSON.stringify(i));
+      if (copy.password) copy.password = null;
+      if (copy.token) copy.token = null;
+      return copy;
+    });
+  } catch (e) {
+    return Array.isArray(items) ? items : [items];
+  }
+}
+// ----------------------
+// TOOL DEFINITIONS
+// ----------------------
+// This object maps tool names to actual execution functions.
+// Each function takes a `params` object and returns a JSON-serializable result.
+MCP.tools = {
+  // List all schema names in the system
+  listSchemas: async (_params, _ctx) => {
+    const list = (Schemas && (
+      (Schemas.schemaList && Schemas.schemaList.length && Schemas.schemaList) ||
+      (Schemas.schema && Object.keys(Schemas.schema))
+    )) || [];
+    return list.slice().sort();
+  },
+  // Get full schema definition by name
+  getSchema: async ({ name }, _ctx) => {
+    if (!name) throw new Error("Missing required param 'name'");
+    const def = Schemas.schema && Schemas.schema[name];
+    if (!def) throw new Error(`Schema "${name}" not found`);
+    return def;
+  },
+  // Convenience: fetch a single object by _id (schema optional). Prefer cache; fallback to storage.
+  getObject: async ({ _id, schema, flatten = true, depth = 1 }, _ctx) => {
+    if (!_id) throw new Error("Missing required param '_id'");
+    // Fast path via global lookup
+    let obj = (JOE && JOE.Cache && JOE.Cache.findByID) ? (JOE.Cache.findByID(_id) || null) : null;
+    if (!obj && schema) {
+      const results = await loadFromStorage(schema, { _id });
+      obj = (results && results[0]) || null;
+    }
+    if (!obj && schema && JOE && JOE.Cache && JOE.Cache.findByID) {
+      obj = JOE.Cache.findByID(schema, _id) || null;
+    }
+    if (!obj) throw new Error(`Object not found${schema?(' in '+schema):''} with _id: ${_id}`);
+    if (flatten && JOE && JOE.Utils && JOE.Utils.flattenObject) {
+      try { return sanitizeItems(JOE.Utils.flattenObject(_id, { recursive: true, depth }))[0]; } catch(e) {}
+    }
+    return sanitizeItems(obj)[0];
+  },
+  /* Deprecated: use unified 'search' instead
+  getObjectsByIds: async () => { throw new Error('Use search with ids instead'); },
+  queryObjects: async () => { throw new Error('Use search instead'); },
+  */
+  /* Deprecated: use unified 'search' instead
+  searchCache: async () => { throw new Error('Use search instead'); },
+  */
+  // Unified search: defaults to cache; set source="storage" to query DB for a schema
+  search: async ({ schema, query = {}, ids, source = 'cache', limit = 50, flatten = false, depth = 1 }, _ctx) => {
+    const useCache = !source || source === 'cache';
+    const useStorage = source === 'storage';
+    if (ids && !Array.isArray(ids)) throw new Error("'ids' must be an array if provided");
+    // When ids are provided and a schema is known, prefer cache for safety/speed
+    if (Array.isArray(ids) && schema) {
+      let items = [];
+      if (JOE && JOE.Cache && JOE.Cache.findByID) {
+        const found = JOE.Cache.findByID(schema, ids.join(',')) || [];
+        items = Array.isArray(found) ? found : (found ? [found] : []);
+      }
+      if (useStorage && (!items || items.length === 0)) {
+        try {
+          const fromStorage = await loadFromStorage(schema, { _id: { $in: ids } });
+          items = fromStorage || [];
+        } catch (e) { /* ignore storage errors here */ }
+      }
+      if (flatten && JOE && JOE.Utils && JOE.Utils.flattenObject) {
+        try { items = ids.map(id => JOE.Utils.flattenObject(id, { recursive: true, depth })); } catch (e) {}
+      }
+      const sliced = (typeof limit === 'number' && limit > 0) ? items.slice(0, limit) : items;
+      return { items: sanitizeItems(sliced) };
+    }
+    // No ids: choose source
+    if (useCache) {
+      if (!JOE || !JOE.Cache || !JOE.Cache.search) throw new Error('Cache not initialized');
+      let results = JOE.Cache.search(query || {});
+      if (schema) results = (results || []).filter(i => i && i.itemtype === schema);
+      const sliced = (typeof limit === 'number' && limit > 0) ? results.slice(0, limit) : results;
+      return { items: sanitizeItems(sliced) };
+    }
+    if (useStorage) {
+      if (!schema) throw new Error("'schema' is required when source=storage");
+      const results = await loadFromStorage(schema, query || {});
+      const sliced = (typeof limit === 'number' && limit > 0) ? (results || []).slice(0, limit) : (results || []);
+      if (flatten && JOE && JOE.Utils && JOE.Utils.flattenObject) {
+        try { return { items: sanitizeItems(sliced.map(it => JOE.Utils.flattenObject(it && it._id, { recursive: true, depth }))) }; } catch (e) {}
+      }
+      return { items: sanitizeItems(sliced) };
+    }
+    throw new Error("Invalid 'source'. Use 'cache' (default) or 'storage'.");
+  },
+  // Save an object via Storage (respects events/history)
+  saveObject: async ({ object }, ctx = {}) => {
+    if (!object || !object.itemtype) throw new Error("'object' with 'itemtype' is required");
+    const user = (ctx.req && ctx.req.User) ? ctx.req.User : { name: 'anonymous' };
+    const saved = await new Promise((resolve, reject) => {
+      try {
+        Storage.save(object, object.itemtype, function(err, data){
+          if (err) return reject(err);
+          resolve(data);
+        }, { user });
+      } catch (e) { reject(e); }
+    });
+    return sanitizeItems(saved)[0];
+  },
+  // Hydration: surface core fields (from file), all schemas, statuses, and tags (no params)
+  hydrate: async (_params, _ctx) => {
+    let coreDef = (JOE && JOE.Fields && JOE.Fields['core']) || null;
+    if (!coreDef) {
+      try { coreDef = require(__dirname + '/../fields/core.js'); } catch (_e) { coreDef = {}; }
+    }
+    const coreFields = Object.keys(coreDef || {}).map(name => ({
+      name,
+      definition: coreDef[name]
+    }));
+    const payload = {
+      coreFields,
+      schemas: Object.keys(Schemas?.schema || {})
+    };
+    payload.statuses = sanitizeItems(JOE.Data?.status || []);
+    payload.tags = sanitizeItems(JOE.Data?.tag || [])
+    return payload;
+  }
+  // 🔧 Add more tools here as needed
+};
+// ----------------------
+// METADATA FOR TOOLS
+// ----------------------
+// These are used to auto-generate the MCP manifest from the function registry
+MCP.descriptions = {
+  listSchemas: "List all available JOE schema names.",
+  getSchema: "Retrieve a full schema definition by name.",
+  getObject: "Fetch a single object by _id (schema optional). Flattens by default.",
+  // getObjectsByIds: "Deprecated - use 'search' with ids.",
+  // queryObjects: "Deprecated - use 'search'.",
+  // searchCache: "Deprecated - use 'search'.",
+  search: "Unified search. Defaults to cache; set source=storage to query DB.",
+  saveObject: "Create/update an object; triggers events/history.",
+  hydrate: "Describe core fields, statuses, tags, and inferred field shapes for an optional schema."
+};
+MCP.params = {
+  listSchemas: {},
+  getSchema: {
+    type: "object",
+    properties: {
+      name: { type: "string" }
+    },
+    required: ["name"]
+  },
+  getObject: {
+    type: "object",
+    properties: {
+      _id: { type: "string" },
+      schema: { type: "string" },
+      flatten: { type: "boolean" },
+      depth: { type: "integer" }
+    },
+    required: ["_id"]
+  },
+  // getObjectsByIds: { ...deprecated },
+  // queryObjects: { ...deprecated },
+  // searchCache: { ...deprecated },
+  search: {
+    type: "object",
+    properties: {
+      schema: { type: "string" },
+      query: { type: "object" },
+      ids: { type: "array", items: { type: "string" } },
+      source: { type: "string", enum: ["cache","storage"] },
+      limit: { type: "integer" },
+      flatten: { type: "boolean" },
+      depth: { type: "integer" }
+    },
+    required: []
+  },
+  saveObject: {
+    type: "object",
+    properties: {
+      object: { type: "object" }
+    },
+    required: ["object"]
+  },
+  hydrate: { type: "object", properties: {} }
+};
+MCP.returns = {
+  listSchemas: {
+    type: "array",
+    items: { type: "string" }
+  },
+  getSchema: { type: "object" },
+  getObject: { type: "object" },
+  // getObjectsByIds: { ...deprecated },
+  // queryObjects: { ...deprecated },
+  // searchCache: { ...deprecated },
+  search: {
+    type: "object",
+    properties: {
+      items: { type: "array", items: { type: "object" } }
+    }
+  },
+  saveObject: { type: "object" },
+  hydrate: { type: "object" }
+};
+// ----------------------
+// MANIFEST HANDLER
+// ----------------------
+// Responds to GET /.well-known/mcp/manifest.json
+// Returns tool descriptions for agent discovery
+MCP.manifest = async function (req, res) {
+  try {
+    const toolNames = Object.keys(MCP.tools);
+    const tools = toolNames.map(name => ({
+      name,
+      description: MCP.descriptions[name],
+      params: MCP.params[name],
+      returns: MCP.returns[name]
+    }));
+    const joe = {
+      name: (JOE && JOE.webconfig && JOE.webconfig.name) || 'JOE',
+      version: (JOE && JOE.VERSION) || '',
+      hostname: (JOE && JOE.webconfig && JOE.webconfig.hostname) || ''
+    };
+    return res.json({ version: "1.0", joe, tools });
+  } catch (e) {
+    console.log('[MCP] manifest error:', e);
+    return res.status(500).json({ error: e.message || 'manifest error' });
+  }
+};
+// ----------------------
+// JSON-RPC HANDLER
+// ----------------------
+// Responds to POST /mcp with JSON-RPC 2.0 calls
+MCP.rpcHandler = async function (req, res) {
+  const { id, method, params } = req.body;
+  // Validate method
+  if (!MCP.tools[method]) {
+    return res.status(400).json({
+      jsonrpc: "2.0",
+      id,
+      error: { code: -32601, message: "Method not found" }
+    });
+  }
+  try {
+    const result = await MCP.tools[method](params, { req, res });
+    return res.json({ jsonrpc: "2.0", id, result });
+  } catch (err) {
+    console.error(`[MCP] Error in method ${method}:`, err);
+    return res.status(500).json({
+      jsonrpc: "2.0",
+      id,
+      error: { code: -32000, message: err.message || "Internal error" }
+    });
+  }
+};
+module.exports = MCP;
+// Optional initializer to attach routes without modifying Server.js
+MCP.init = function initMcpRoutes(){
+  try {
+    if (!global.JOE || !JOE.Server) return;
+    if (JOE._mcpInitialized) return;
+    const server = JOE.Server;
+    const auth = JOE.auth; // may be undefined for manifest
+    server.get('/.well-known/mcp/manifest.json', function(req, res){
+      return MCP.manifest(req, res);
+    });
+    if (auth) {
+      server.post('/mcp', auth, function(req, res){ return MCP.rpcHandler(req, res); });
+    } else {
+      server.post('/mcp', function(req, res){ return MCP.rpcHandler(req, res); });
+    }
+    JOE._mcpInitialized = true;
+    console.log('[MCP] routes attached');
+  } catch (e) {
+    console.log('[MCP] init error:', e);
+  }
+};

package/server/modules/Server.js CHANGED Viewed

@@ -106,7 +106,6 @@ server.use(function(req, res, next) {
 });
 server.use(JOE.webconfig.joepath,express.static(JOE.joedir));
 //USER
 server.get(['/API/user/:method'],auth,function(req,res,next){
     var users = (JOE.Data && JOE.Data.user) || [];
@@ -809,6 +808,8 @@ JOE.Utils.setupFileFolder(webDir,'web');
 server.use('/',express.static(JOE.webDir));
+// Also serve JOE's own _www as a fallback under root (parent app takes priority)
+server.use('/',express.static(path.join(JOE.joedir, JOE.webconfig.webDir)));
 http.listen(JOE.webconfig.port,function(){
     //console.log('joe listening on '+JOE.webconfig.port);