mnfst 0.5.165 → 0.5.166

package/lib/manifest.chat.js

@@ -455,6 +455,106 @@
 })();
 
 
+/*  Manifest Chat — optional LLM (Claude) adapter
+ *  By Andrew Matlock under MIT license · https://manifestx.dev
+ *
+ *  Reference `claude` adapter: replies stream from a backend proxy holding the
+ *  API key (tools/chat-llm-proxy.mjs). $chat never calls the LLM — this adapter
+ *  does, behind the same contract. Optional, loaded separately from the bundle.
+ *  Attachments ride draft.body.media[] as base64 → image/document blocks.
+ */
+
+(function () {
+    'use strict';
+
+    function ready(fn) {
+        if (window.ManifestChatAdapters) return fn();
+        const t = setInterval(() => { if (window.ManifestChatAdapters) { clearInterval(t); fn(); } }, 20);
+        setTimeout(() => clearInterval(t), 5000);
+    }
+
+    ready(function () {
+        const USER = { id: 'you', kind: 'human', role: 'user', displayName: 'You', color: '#7c3aed' };
+        const BOT = { id: 'claude', kind: 'agent', role: 'assistant', displayName: 'Claude', color: '#d97706' };
+
+        function claudeAdapter(opts) {
+            opts = opts || {};
+            // Same-origin relay mnfst-run serves for an `ai` block; override via
+            // opts.endpoint / window.CHAT_LLM_ENDPOINT.
+            const endpoint = opts.endpoint || window.CHAT_LLM_ENDPOINT || '/_ai/chat';
+            const system = opts.system || 'You are a helpful assistant for the Manifest framework docs. Answer in concise markdown.';
+            const handlers = {};   // conversationId -> subscribe handlers
+            let seq = 0;
+            const id = (p) => p + '_' + Date.now().toString(36) + '_' + (++seq);
+            const lsKey = (cid) => 'mnfst.chat.' + cid;
+
+            // text-only persistence so docs sessions survive reload (attachments stay ephemeral)
+            function loadStore(cid) { try { return JSON.parse(localStorage.getItem(lsKey(cid)) || '[]'); } catch { return []; } }
+            function saveMsg(cid, m) {
+                const all = loadStore(cid);
+                all.push({ id: m.id, role: m.author.kind === 'agent' ? 'assistant' : 'user', text: m.body.text, ts: m.ts });
+                try { localStorage.setItem(lsKey(cid), JSON.stringify(all.slice(-200))); } catch { }
+            }
+            const toMsg = (r) => ({ id: r.id, conversationId: null, author: r.role === 'assistant' ? BOT : USER, body: { text: r.text }, ts: r.ts, status: 'delivered' });
+
+            // Build the Anthropic messages array; attachments → image/document blocks.
+            function apiMessages(cid, draft) {
+                const hist = loadStore(cid).map(r => ({ role: r.role, content: r.text }));
+                const media = (draft.body && draft.body.media) || [];
+                const blocks = media.map(a => a.kind === 'image'
+                    ? { type: 'image', source: { type: 'base64', media_type: a.mediaType, data: a.data } }
+                    : { type: 'document', source: { type: 'base64', media_type: a.mediaType || 'application/pdf', data: a.data } });
+                const text = (draft.body && draft.body.text) || draft.text || '';
+                const last = blocks.length ? { role: 'user', content: [...blocks, { type: 'text', text }] } : { role: 'user', content: text };
+                return [...hist, last];
+            }
+
+            async function streamReply(cid) {
+                const h = handlers[cid]; if (!h) return;
+                const messages = streamReply._pending; streamReply._pending = null;
+                const mid = id('m');
+                h.onMessage && h.onMessage({ id: mid, conversationId: cid, author: BOT, body: { text: '' }, ts: Date.now(), status: 'streaming', meta: { model: opts.model } });
+                let full = '';
+                try {
+                    const resp = await fetch(endpoint, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ system, model: opts.model, messages }) });
+                    const reader = resp.body.getReader(); const dec = new TextDecoder(); let buf = '';
+                    for (; ;) {
+                        const { done, value } = await reader.read(); if (done) break;
+                        buf += dec.decode(value, { stream: true });
+                        let i;
+                        while ((i = buf.indexOf('\n\n')) >= 0) {
+                            const frame = buf.slice(0, i); buf = buf.slice(i + 2);
+                            const line = frame.split('\n').find(l => l.startsWith('data:')); if (!line) continue;
+                            let evt; try { evt = JSON.parse(line.slice(5).trim()); } catch { continue; }
+                            if (evt.type === 'content_block_delta' && evt.delta && evt.delta.type === 'text_delta') {
+                                full += evt.delta.text; h.onMessagePart && h.onMessagePart(mid, { text: evt.delta.text });
+                            } else if (evt.type === 'error') { full += '\n\n_(error: ' + (evt.error && evt.error.message) + ')_'; h.onMessagePart && h.onMessagePart(mid, { text: '\n\n_(error)_' }); }
+                        }
+                    }
+                } catch (e) { h.onMessagePart && h.onMessagePart(mid, { text: '\n\n_(proxy unreachable — is tools/chat-llm-proxy.mjs running?)_' }); full += ' (proxy unreachable)'; }
+                h.onMessagePart && h.onMessagePart(mid, { text: '', done: true });
+                saveMsg(cid, { id: mid, author: BOT, body: { text: full }, ts: Date.now() });
+            }
+
+            return {
+                identity: () => USER,
+                async load(cid) { return { messages: loadStore(cid).map(toMsg), participants: [USER, BOT] }; },
+                subscribe(cid, h) { handlers[cid] = h; setTimeout(() => h.onConnection && h.onConnection(true), 0); return () => { delete handlers[cid]; }; },
+                async send(cid, draft) {
+                    const mid = id('m'); const ts = Date.now();
+                    saveMsg(cid, { id: mid, author: USER, body: { text: (draft.body && draft.body.text) || draft.text || '' }, ts });
+                    streamReply._pending = apiMessages(cid, draft);
+                    setTimeout(() => streamReply(cid), 30);   // assistant reply streams in as a separate inbound
+                    return { id: mid, ts };
+                }
+            };
+        }
+
+        window.ManifestChatAdapters.register('claude', claudeAdapter);
+    });
+})();
+
+
 /*  Manifest Chat — magic + init
 /*  By Andrew Matlock under MIT license
 /*  https://manifestx.dev

package/lib/manifest.integrity.json

@@ -3,7 +3,7 @@
   "manifest.appwrite.data.js": "sha384-KFKVo5TQESLJB7wgk+C8Zb/sAl43QAMdioWW3tQRWYq5umfdpGCZ5Hld9y9f6/Np",
   "manifest.appwrite.presences.js": "sha384-JyVDWFT69b7Svq8J8p9tNWe2v9PZNQBY5UyhtOl1vnuHFAX0CRQ3MA9SiKq5wzNh",
   "manifest.charts.js": "sha384-wTQlB3hJ9V9lmisCgm8l6YkpJV+nA4+Vci3dI0x1nBtWnS9TFr+eXaJelP7AusyD",
-  "manifest.chat.js": "sha384-HDyzPvNxqUOKVcLC3HNSFd5w83Flgm58LHy1BDLB9ejUsbYHAmr34G4X3FwKXokW",
+  "manifest.chat.js": "sha384-lBsqJdnSC4Gclt+te4Yh5V1LXZSGn3CCeCKPwtOk5gp6UlCROigBepvaAY3NKNZp",
   "manifest.code.js": "sha384-G3MNfvQRWWY+gm4SGGrSsgQbDeil9MP+ON2DTk6Rcq9Nsex8woHMDt5EJHrFH0Nj",
   "manifest.color.js": "sha384-6Rv3LxyTcZNjrhtayQfqRdCx0uSZ4BiEbgEI98I62eTvp8Aw7LBIoNJ0Je1oktwL",
   "manifest.colorpicker.js": "sha384-N5ezEwgKrDodV4YdURxhdyZKmg1n/QhqvmAC4SEG03mw1pEAZAA8Gphp+NLAOxts",
@@ -29,5 +29,5 @@
   "manifest.url.parameters.js": "sha384-FIufiClqDx1rJpU/QUc9z/D43qClQ6Qm8rBahipbJl9BDHUvhrOsUDegmTWW7Tuf",
   "manifest.utilities.js": "sha384-MtzNaVOrgyepjlY5nz38pAJk67yiFPU1H5WoPNfcNbUZTXy+oin1lrtKCIcobEOJ",
   "manifest.virtual.js": "sha384-c194pXD0Ld48QJ+HPVNibvbn54/ETJRuYhUOWesEBjtOIQcQMIKo0DnCyQMvDlLg",
-  "manifest.js": "sha384-VshJgT9QAxsLpwNmQZfrxw/EAxoyLIklo0DsmhxLhjVmmT70fLmn5eNRuq98o6zs"
+  "manifest.js": "sha384-RusFaByZu31LkLZCAhjgtJC8iWksvmjTKS8D5Xj9/4N7B/Xr4DDyFGmiL23kajgK"
 }

package/lib/manifest.js

@@ -202,11 +202,29 @@
 
 	// Configuration
 	const DEFAULT_VERSION = 'latest';
-	const ALPINE_CDN_URL = 'https://cdn.jsdelivr.net/npm/alpinejs@3/dist/cdn.min.js';
+
+	// CDN fallback chain (first-party first). Each origin serves the npm scheme
+	// `<origin>/<pkg>@<version>/<path>`. Override order with `data-cdn`
+	// (comma-separated origins).
+	let CDN_HOSTS = [
+		'https://cdn.manifestx.dev/npm',
+		'https://cdn.jsdelivr.net/npm',
+		'https://unpkg.com'
+	];
+	function setCdnHosts(value) {
+		if (!value) return;
+		const hosts = value.split(',').map(s => s.trim().replace(/\/$/, '')).filter(Boolean);
+		if (hosts.length) CDN_HOSTS = hosts;
+	}
+
+	// unpkg serves packages as published (no auto-minify); mnfst ships unminified .js.
+	function hostFile(host, file) {
+		return host.includes('unpkg.com') ? file.replace(/\.min\.js$/, '.js') : file;
+	}
 
 	// Get base URL for a given version
-	function getBaseUrl(version = DEFAULT_VERSION) {
-		return `https://cdn.jsdelivr.net/npm/mnfst@${version}/lib`;
+	function getBaseUrl(version = DEFAULT_VERSION, host = CDN_HOSTS[0]) {
+		return `${host}/mnfst@${version}/lib`;
 	}
 
 	// Available core plugins (auto-loaded if no data-plugins specified)
@@ -279,26 +297,29 @@
 		});
 	}
 
-	// Plugin URL: `data-plugin-base` override → unminified `.js`; else the
-	// jsDelivr CDN as `.min.js`.
+	// Plugin URLs: `data-plugin-base` override → single unminified `.js` (no
+	// fallback — an explicit base, e.g. local dev, must fail loudly); else one
+	// candidate per CDN host, tried in order.
 	let _pluginBase = null;
 	function setPluginBase(b) { _pluginBase = b || null; }
-	function getPluginUrl(pluginName, version = DEFAULT_VERSION) {
+	function getPluginUrlCandidates(pluginName, version = DEFAULT_VERSION) {
 		// Hyphenated API name → dotted file name (`appwrite-auth` → appwrite.auth).
 		const fileName = pluginName.replace(/-/g, '.');
 		if (_pluginBase) {
 			const base = _pluginBase.replace(/\/$/, '');
-			return `${base}/manifest.${fileName}.js`;
+			return [`${base}/manifest.${fileName}.js`];
 		}
-		const base = getBaseUrl(version);
-		return `${base}/manifest.${fileName}.min.js`;
+		return CDN_HOSTS.map(h => `${getBaseUrl(version, h)}/${hostFile(h, `manifest.${fileName}.min.js`)}`);
+	}
+	function getPluginUrl(pluginName, version = DEFAULT_VERSION) {
+		return getPluginUrlCandidates(pluginName, version)[0];
 	}
 
-	// Resolve Alpine CDN URL from a data-alpine value (version tag or full URL)
-	function resolveAlpineUrl(dataAlpine) {
-		if (!dataAlpine) return ALPINE_CDN_URL;
-		if (dataAlpine.startsWith('http')) return dataAlpine;
-		return `https://cdn.jsdelivr.net/npm/alpinejs@${dataAlpine}/dist/cdn.min.js`;
+	// Alpine URL candidates from a data-alpine value (version tag or full URL)
+	function alpineUrlCandidates(dataAlpine) {
+		if (dataAlpine && dataAlpine.startsWith('http')) return [dataAlpine];
+		const v = dataAlpine || '3';
+		return CDN_HOSTS.map(h => `${h}/alpinejs@${v}/dist/cdn.min.js`);
 	}
 
 	// Has DOMContentLoaded fired? readyState can't tell ('interactive' spans
@@ -331,7 +352,7 @@
 	// fire `alpine:init` before the page's registrations exist. DCL fires only
 	// after every deferred script runs, making the order deterministic (and cold
 	// cache is already past DCL, so no added delay).
-	function loadAlpine(alpineUrl = ALPINE_CDN_URL) {
+	function loadAlpine(alpineUrls) {
 		whenDomReady(() => {
 			if (window.Alpine) {
 				return;
@@ -343,24 +364,30 @@
 				return;
 			}
 
-			const script = document.createElement('script');
-			script.src = alpineUrl;
-			// No `defer` — past DCL, so execute as soon as it arrives.
-			document.head.appendChild(script);
+			// Past DCL, so each candidate executes as soon as it arrives; fall
+			// through the CDN chain on error.
+			(async () => {
+				for (const url of alpineUrls) {
+					try {
+						return await injectScript(url);
+					} catch (_) {
+						console.warn(`[Manifest Loader] Alpine failed from ${url} — trying fallback CDN`);
+					}
+				}
+				console.error('[Manifest Loader] Alpine.js failed to load from all CDNs.');
+			})();
 		});
 	}
 
-	// Add a script tag to the head and wait for it to load and execute
-	function addScript(pluginName, version = DEFAULT_VERSION) {
+	// Inject one script URL and wait for it to load and execute
+	function injectScript(url) {
 		return new Promise((resolve, reject) => {
-			const url = getPluginUrl(pluginName, version);
-
 			// Skip if script with same src already in DOM (e.g. prerendered HTML or second loader run)
 			const existing = document.querySelector(`script[src="${url}"]`);
 			if (existing) {
 				if (existing.complete) return resolve();
 				existing.addEventListener('load', () => resolve());
-				existing.addEventListener('error', () => reject(new Error(`Failed to load ${pluginName} from ${url}`)));
+				existing.addEventListener('error', () => reject(new Error(`Failed to load ${url}`)));
 				return;
 			}
 
@@ -368,11 +395,28 @@
 			script.src = url;
 			script.async = false; // Ensure scripts execute in order
 			script.onload = () => resolve();
-			script.onerror = () => reject(new Error(`Failed to load ${pluginName} from ${url}`));
+			script.onerror = () => { script.remove(); reject(new Error(`Failed to load ${url}`)); };
 			document.head.appendChild(script);
 		});
 	}
 
+	// Load a plugin, falling through the CDN chain on error. A fallback insert
+	// lands after already-inserted scripts, so strict cross-plugin execution
+	// order is traded for availability in the (already degraded) fallback case.
+	async function addScript(pluginName, version = DEFAULT_VERSION) {
+		const urls = getPluginUrlCandidates(pluginName, version);
+		let lastErr = null;
+		for (const url of urls) {
+			try {
+				return await injectScript(url);
+			} catch (e) {
+				lastErr = e;
+				if (urls.length > 1) console.warn(`[Manifest Loader] ${url} failed — trying fallback CDN`);
+			}
+		}
+		throw lastErr || new Error(`Failed to load ${pluginName}`);
+	}
+
 	// Resolve plugin dependencies (auto-inject required dependencies)
 	function resolveDependencies(pluginList) {
 		const resolved = [];
@@ -435,6 +479,15 @@
 		return [];
 	}
 
+	// Detect the chat plugin from manifest.json content.
+	// Opt-in / auto-loaded when an `ai` (or `chat`) config block is present.
+	function detectChatPlugins(manifest) {
+		if (!manifest || typeof manifest !== 'object') return [];
+		if ((manifest.ai && typeof manifest.ai === 'object') ||
+			(manifest.chat && typeof manifest.chat === 'object')) return ['chat'];
+		return [];
+	}
+
 	// Parse data attributes
 	function parseDataAttributes() {
 		// Try to get current script first, then fall back to querySelector
@@ -455,6 +508,8 @@
 		// Override: resolve plugin URLs against this base (dir serving
 		// `manifest.<name>.js`, relative or absolute) instead of the CDN.
 		const pluginBase = script.getAttribute('data-plugin-base');
+		// Override: custom CDN fallback chain (comma-separated origins).
+		const cdn = script.getAttribute('data-cdn');
 
 		let pluginList = [];
 		const deriveFromManifest = !plugins;
@@ -483,37 +538,29 @@
 			version,
 			alpine,
 			pluginBase,
+			cdn,
 		};
 	}
 
-	// Load custom Tailwind CDN script
-	function loadTailwind(version = DEFAULT_VERSION) {
-		return new Promise((resolve, reject) => {
-			const base = getBaseUrl(version);
-			const tailwindUrl = `${base}/manifest.tailwind.min.js`;
-
-			// Check if already loaded
-			const existing = document.querySelector(`script[src="${tailwindUrl}"]`);
-			if (existing && existing.complete) {
-				return resolve();
+	// Load custom Tailwind CDN script, falling through the CDN chain on error
+	async function loadTailwind(version = DEFAULT_VERSION) {
+		const urls = CDN_HOSTS.map(h => `${getBaseUrl(version, h)}/${hostFile(h, 'manifest.tailwind.min.js')}`);
+		let lastErr = null;
+		for (const url of urls) {
+			try {
+				return await injectScript(url);
+			} catch (e) {
+				lastErr = e;
 			}
-
-			const script = document.createElement('script');
-			script.src = tailwindUrl;
-			script.async = false;
-			script.onload = () => resolve();
-			script.onerror = () => {
-				console.warn(`[Manifest Loader] Tailwind plugin not yet published to CDN. Load it directly: <script src="/scripts/tailwind.v4.3.1.js"></script>`);
-				reject(new Error(`Tailwind plugin not available from CDN. Load it directly from your project.`));
-			};
-			document.head.appendChild(script);
-		});
+		}
+		console.warn(`[Manifest Loader] Tailwind plugin not available from any CDN. Load it directly: <script src="/scripts/tailwind.v4.3.1.js"></script>`);
+		throw lastErr || new Error(`Tailwind plugin not available from CDN.`);
 	}
 
 	// Expose API
 	window.Manifest = {
 		loadPlugin: function (pluginName, version = DEFAULT_VERSION) {
-			const allPlugins = [...AVAILABLE_PLUGINS, ...APPWRITE_PLUGINS, 'payments'];
+			const allPlugins = [...AVAILABLE_PLUGINS, ...APPWRITE_PLUGINS, 'payments', 'chat'];
 			if (!allPlugins.includes(pluginName)) {
 				console.warn(`[Manifest Loader] Unknown plugin: ${pluginName}`);
 				return Promise.reject(new Error(`Unknown plugin: ${pluginName}`));
@@ -532,6 +579,7 @@
 	// Parse config and load plugins
 	const config = parseDataAttributes();
 	if (config && config.pluginBase) setPluginBase(config.pluginBase);
+	if (config && config.cdn) setCdnHosts(config.cdn);
 
 	if (config && config.plugins.length > 0) {
 		if (window.__manifestLoaderStarted) {
@@ -605,7 +653,8 @@
 				const corePlugins = getDefaultPluginsFromManifest(manifest);
 				const appwritePlugins = detectAppwritePlugins(manifest);
 				const paymentsPlugins = detectPaymentsPlugins(manifest);
-				pluginsToLoad = resolveDependencies([...corePlugins, ...appwritePlugins, ...paymentsPlugins]);
+				const chatPlugins = detectChatPlugins(manifest);
+				pluginsToLoad = resolveDependencies([...corePlugins, ...appwritePlugins, ...paymentsPlugins, ...chatPlugins]);
 			} else {
 				const needsManifest = config.plugins.some(p => MANIFEST_DEPENDENT_PLUGINS.includes(p));
 				if (needsManifest) {
@@ -634,7 +683,7 @@
 					window.ManifestComponentsRegistry.manifest = manifest;
 				}
 			}
-			loadAlpine(resolveAlpineUrl(config.alpine));
+			loadAlpine(alpineUrlCandidates(config.alpine));
 		};
 
 		loadPlugins();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "mnfst",
-    "version": "0.5.165",
+    "version": "0.5.166",
     "private": false,
     "workspaces": [
         "templates/starter",
@@ -27,7 +27,7 @@
         "render": "node src/scripts/manifest.render.mjs --root src",
         "prerender:docs": "node src/scripts/manifest.render.mjs --root docs",
         "prerender:starter": "node src/scripts/manifest.render.mjs --root templates/starter",
-        "release": "node scripts/release-bump.mjs . && npm publish",
+        "release": "node scripts/release-bump.mjs . && npm publish && node scripts/cdn-warm.mjs",
         "release:run": "node scripts/release-bump.mjs packages/run && cd packages/run && npm publish --auth-type=web",
         "release:render": "node scripts/release-bump.mjs packages/render && cd packages/render && npm publish --auth-type=web",
         "release:types": "node scripts/release-bump.mjs packages/types && cd packages/types && npm publish --auth-type=web",