@cldmv/slothlet 1.0.1 → 2.0.1

package/dist/lib/engine/slothlet_helpers.mjs

@@ -0,0 +1,454 @@
+/*
+	Copyright 2025 CLDMV/Shinrai
+
+	Licensed under the Apache License, Version 2.0 (the "License");
+	you may not use this file except in compliance with the License.
+	You may obtain a copy of the License at
+
+		http://www.apache.org/licenses/LICENSE-2.0
+
+	Unless required by applicable law or agreed to in writing, software
+	distributed under the License is distributed on an "AS IS" BASIS,
+	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	See the License for the specific language governing permissions and
+	limitations under the License.
+*/
+
+
+import vm from "node:vm";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+
+
+
+
+
+
+export function normalizeContext(ctx) {
+	if (ctx == null) return {};
+	if (isPlainObject(ctx)) return { ...ctx };
+	if (!Array.isArray(ctx)) {
+		const named = guessName(ctx);
+		return named ? { [named]: ctx, context: ctx } : { context: ctx };
+	}
+	const out = {};
+	for (const item of ctx) {
+		if (Array.isArray(item) && item.length === 2 && typeof item[0] === "string") {
+			out[item[0]] = item[1];
+			continue;
+		}
+		if (isPlainObject(item) && "name" in item && "value" in item) {
+			out[item.name] = item.value;
+			continue;
+		}
+		if (typeof item === "function" && item.name) {
+			out[item.name] = item;
+			continue;
+		}
+		throw new Error("Context array items must be [name,value], {name,value}, or a named function");
+	}
+	return out;
+}
+
+export function installGlobalsInCurrentRealm(contextMap) {
+	globalThis.context = Object.freeze({ ...contextMap });
+	for (const k of Object.keys(contextMap)) globalThis[k] = contextMap[k];
+}
+
+export function extendSelfWithReference(self, reference) {
+	if (reference && typeof reference === "object") {
+		for (const k of Object.keys(reference)) {
+			if (!(k in self)) {
+				try {
+					self[k] = reference[k];
+				} catch {
+					
+				}
+			}
+		}
+	}
+}
+
+export function installPortalForSelf() {
+	function get(o, p) {
+		let x = o;
+		for (const k of p) {
+			if (!x) {
+				
+				return undefined;
+			}
+			
+			x = x[k];
+		}
+		return x;
+	}
+	globalThis._portal = {
+		call(path, args) {
+			
+			const obj = get(globalThis.self, path.slice(0, -1));
+			const fn = obj ? obj[path[path.length - 1]] : undefined;
+			
+			if (typeof fn !== "function") {
+				
+				throw new TypeError("Resolved value is not a function");
+			}
+			return fn.apply(obj, args);
+		},
+		batch(ops) {
+			return ops.map((op) => this.call(op.path, op.args || []));
+		}
+	};
+}
+
+export function asUrl(p) {
+	return p && p.startsWith && p.startsWith("file:") ? p : pathToFileURL(path.resolve(String(p))).href;
+}
+
+export function isPlainObject(o) {
+	return !!o && typeof o === "object" && (o.constructor === Object || Object.getPrototypeOf(o) === null);
+}
+
+export function guessName(v) {
+	if (typeof v === "function" && v.name) return v.name;
+	if (isPlainObject(v) && v.constructor && v.constructor.name && v.constructor.name !== "Object") {
+		const n = v.constructor.name;
+		return n[0].toLowerCase() + n.slice(1);
+	}
+	return null;
+}
+
+
+
+
+
+export const HAS_STM = typeof vm.SourceTextModule === "function";
+
+export function makeNodeishContext() {
+	const sandbox = {
+		console,
+		process,
+		Buffer,
+		setTimeout,
+		clearTimeout,
+		setInterval,
+		clearInterval,
+		setImmediate,
+		clearImmediate,
+		queueMicrotask,
+		TextEncoder,
+		TextDecoder,
+		URL,
+		URLSearchParams,
+		AbortController,
+		AbortSignal,
+		performance,
+		Function
+	};
+	const context = vm.createContext(sandbox);
+	context.globalThis = context;
+	context.global = context;
+	return context;
+}
+
+
+export async function loadEsmInVm2(context, fileUrl, mode = "auto") {
+	console.debug(`[loadEsmInVm] fileUrl: ${fileUrl}, mode: ${mode}`);
+	
+	const code = await fs.readFile(fileURLToPath(fileUrl), "utf8");
+	let detectedMode = mode;
+	console.debug(`[loadEsmInVm] detectedMode: ${detectedMode} for fileUrl: ${fileUrl}`);
+	if (mode === "auto") {
+		const ext = path.extname(fileURLToPath(fileUrl)).toLowerCase();
+		if (ext === ".mjs") detectedMode = "mjs";
+		else if (ext === ".cjs") detectedMode = "cjs";
+		else if (ext === ".js") {
+			if (/\bimport\b/.test(code)) detectedMode = "mjs";
+			else if (/\brequire\b/.test(code)) detectedMode = "cjs";
+			else detectedMode = "cjs"; 
+		} else {
+			detectedMode = "cjs";
+		}
+	}
+
+	if (detectedMode === "cjs") {
+		
+		
+		
+		if (mode === "cjs" || (fileUrl.endsWith(".cjs") && mode === "auto")) {
+			console.debug(`[loadEsmInVm] Loading as CJS: ${fileUrl}`);
+			
+			if (arguments.callee.caller && arguments.callee.caller.name === "loadEsmInVm") {
+				throw new Error("CJS modules are not supported for linker/dynamic import. Only ESM (.mjs) modules are allowed.");
+			}
+			console.debug(
+				`[loadEsmInVm] Returning CJS namespace for ${fileUrl}:`,
+				namespace,
+				"type:",
+				typeof namespace,
+				"constructor:",
+				namespace?.constructor?.name
+			);
+			console.debug(
+				`[loadEsmInVm] [RETURN]`,
+				{ namespace },
+				"type:",
+				typeof { namespace },
+				"constructor:",
+				{ namespace }?.constructor?.name
+			);
+			if (!context.require) {
+				context.require = require;
+			}
+			const script = new vm.Script(code, { filename: fileUrl });
+			script.runInContext(context);
+			const namespace = {};
+			for (const k of Object.keys(context)) {
+				if (k !== "globalThis" && k !== "global") {
+					namespace[k] = context[k];
+				}
+			}
+			console.debug(`[loadEsmInVm] Returning CJS namespace for ${fileUrl}:`, namespace, "type:", typeof namespace);
+			return { namespace };
+		} else {
+			console.error(`[loadEsmInVm] CJS not allowed for linker/dynamic import: ${fileUrl}`);
+			throw new Error("CJS modules are not supported in linker/dynamic import. Only ESM (.mjs) modules are allowed.");
+		}
+	}
+	if (detectedMode === "mjs") {
+		console.debug(`[loadEsmInVm] Loading as ESM: ${fileUrl}`);
+		if (HAS_STM) {
+			const mod = new vm.SourceTextModule(code, {
+				context,
+				identifier: fileUrl,
+				initializeImportMeta(m) {
+					m.url = fileUrl;
+				}
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+				
+			});
+			
+			await mod.evaluate();
+			console.debug("[loadEsmInVm] returning top-level SourceTextModule:", mod, "status:", mod.status);
+			console.debug(`[loadEsmInVm] Returning SourceTextModule for ${fileUrl}:`, mod);
+			return mod;
+		} else {
+			
+			
+			
+			
+			
+			
+			
+			throw new Error("ESM (import/export) not supported in VM context without vm.SourceTextModule. Custom parser not implemented yet.");
+		}
+	}
+
+	console.error(`[loadEsmInVm] [RETURN] ERROR: Unknown module mode: ${detectedMode}`);
+	throw new Error(`Unknown module mode: ${detectedMode}`);
+}
+
+const MODULE_CACHE = Symbol.for("slothlet.vm.moduleCache");
+export async function loadEsmInVm(context, fileUrl) {
+	if (!HAS_STM) {
+		throw new Error("vm.SourceTextModule not available; cannot load ESM inside vm context");
+	}
+	
+	const cache = (context[MODULE_CACHE] ||= new Map());
+	if (cache.has(fileUrl)) return cache.get(fileUrl);
+
+	const code = await fs.readFile(fileURLToPath(fileUrl), "utf8");
+
+	
+	const link = async (specifier, referencingModule) => {
+		const isRel = specifier.startsWith("./") || specifier.startsWith("../") || specifier.startsWith("/") || specifier.startsWith("file:");
+
+		if (isRel) {
+			const childUrl = new URL(specifier, referencingModule.identifier).href;
+			return await loadEsmInVm(context, childUrl); 
+		}
+
+		
+		const ns = await import(specifier);
+		const sm = new vm.SyntheticModule(
+			Object.keys(ns),
+			function init() {
+				for (const k of Object.keys(ns)) this.setExport(k, ns[k]);
+			},
+			{ context }
+		);
+		
+		return sm; 
+	};
+
+	
+	const importModuleDynamically = async (specifier, referencingModule) => {
+		const child = await link(specifier, referencingModule);
+		
+		await child.evaluate();
+		return child;
+	};
+
+	const mod = new vm.SourceTextModule(code, {
+		context,
+		identifier: fileUrl,
+		initializeImportMeta(meta) {
+			meta.url = fileUrl;
+		},
+		importModuleDynamically
+	});
+
+	cache.set(fileUrl, mod);
+	await mod.link(link); 
+
+	
+	return mod;
+}
+
+export function installContextGlobalsVM(context, userContext) {
+	const map = normalizeContext(userContext);
+	context.__ctx = map;
+	vm.runInContext(
+		`
+            globalThis.context = Object.freeze({ ...__ctx });
+            for (const k of Object.keys(__ctx)) { globalThis[k] = __ctx[k]; }
+        `,
+		context,
+		{ filename: "slothlet_helpers-installContextGlobalsVM.mjs" }
+	);
+	delete context.__ctx;
+}
+
+export async function bootSlothletVM(context, entryUrl, loadConfig, ctxRef) {
+	const mod = await loadEsmInVm(context, entryUrl);
+	await mod.evaluate(); 
+	console.log(mod.namespace);
+	console.log("mod.namespace?.slothlet", mod.namespace?.slothlet);
+	console.log("mod.namespace?.default", mod.namespace?.default);
+	console.log(entryUrl);
+	let sloth = mod.namespace?.slothlet;
+	if (!sloth && mod.namespace?.default) {
+		
+		if (mod.namespace.default.slothlet) {
+			sloth = mod.namespace.default.slothlet;
+		} else {
+			
+			sloth = mod.namespace.default;
+		}
+	}
+	if (!sloth) throw new Error("Entry did not export `slothlet`");
+	context.__slothlet = sloth;
+	context.__loadConfig = loadConfig;
+	context.__ctxRef = ctxRef;
+	vm.runInContext(
+		`
+			globalThis.slothletReady = global.slothletReady = new Promise(async (resolve) => {
+				globalThis.slothlet = global.slothlet = __slothlet;
+				const ret = await globalThis.slothlet.load(__loadConfig, __ctxRef);
+				globalThis.self = global.self = ret;
+				const ref = __ctxRef?.reference;
+				if (ref && typeof ref === 'object') {
+					for (const k of Object.keys(ref)) if (!(k in globalThis.self)) {
+						try { globalThis.self[k] = global.self[k] = ref[k]; } catch {}
+					}
+				}
+				function get(o,p){ return p.reduce((x,k)=>x[k], o); }
+				globalThis._portal = global._portal = {
+					call(path, args){
+						const obj = get(globalThis.self || global.self, path.slice(0,-1));
+						const fn  = obj[path[path.length-1]];
+						return fn.apply(obj, args);
+					},
+					batch(ops){ return ops.map(op => this.call(op.path, op.args || [])); }
+				};
+				resolve();
+			});
+		`,
+		context,
+		{ filename: "slothlet_helpers-bootSlothletVM.mjs" }
+	);
+	delete context.__slothlet;
+	delete context.__loadConfig;
+	delete context.__ctxRef;
+}
+
+
+
+export function marshalArgsReplaceFunctions(value, registerCb) {
+	function walk(v) {
+		if (typeof v === "function") {
+			const id = registerCb(v);
+			return { __cb: id }; 
+		}
+		if (!v || typeof v !== "object") return v;
+		if (Array.isArray(v)) return v.map(walk);
+		const out = {};
+		for (const k of Object.keys(v)) out[k] = walk(v[k]);
+		return out;
+	}
+	return walk(value);
+}
+
+export function reviveArgsReplaceTokens(value, invokeCb) {
+	function walk(v) {
+		if (v && typeof v === "object" && typeof v.__cb === "number") {
+			const id = v.__cb;
+			return (...args) => invokeCb(id, args);
+		}
+		if (!v || typeof v !== "object") return v;
+		if (Array.isArray(v)) return v.map(walk);
+		const out = {};
+		for (const k of Object.keys(v)) out[k] = walk(v[k]);
+		return out;
+	}
+	return walk(value);
+}
+
+export function containsFunction(value) {
+	if (typeof value === "function") return true;
+	if (!value || typeof value !== "object") return false;
+	if (Array.isArray(value)) return value.some(containsFunction);
+	return Object.values(value).some(containsFunction);
+}

package/dist/lib/engine/slothlet_worker.mjs

@@ -0,0 +1,148 @@
+/*
+	Copyright 2025 CLDMV/Shinrai
+
+	Licensed under the Apache License, Version 2.0 (the "License");
+	you may not use this file except in compliance with the License.
+	You may obtain a copy of the License at
+
+		http://www.apache.org/licenses/LICENSE-2.0
+
+	Unless required by applicable law or agreed to in writing, software
+	distributed under the License is distributed on an "AS IS" BASIS,
+	WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+	See the License for the specific language governing permissions and
+	limitations under the License.
+*/
+
+
+import { parentPort, workerData } from "node:worker_threads";
+import {
+	installGlobalsInCurrentRealm,
+	extendSelfWithReference,
+	installPortalForSelf,
+	reviveArgsReplaceTokens
+} from "./slothlet_helpers.mjs";
+
+const { entry, loadConfig, contextMap, reference } = workerData;
+
+(async () => {
+	
+	installGlobalsInCurrentRealm(contextMap);
+
+	
+	const { slothlet } = await import(entry);
+	if (!slothlet) throw new Error("Entry did not export `slothlet`");
+
+	const api = await slothlet.load(loadConfig, { context: contextMap, reference });
+	
+	Object.defineProperty(api, "__dispose__", {
+		value: async () => {
+			parentPort.postMessage({ t: "dispose" });
+			setImmediate(() => process.exit(0));
+		},
+		writable: false,
+		enumerable: false,
+		configurable: false
+	});
+	globalThis.self = api;
+
+	
+	extendSelfWithReference(globalThis.self, reference);
+	installPortalForSelf();
+
+	
+	
+	const callbackResults = new Map();
+	parentPort.on("message", async (msg) => {
+		
+		
+		if (msg && msg.t === "callbackResult" && typeof msg.cb === "number") {
+			
+			const resolver = callbackResults.get(msg.cb);
+			if (resolver) {
+				callbackResults.delete(msg.cb);
+				if (msg.ok) resolver.resolve(msg.result);
+				else resolver.reject(new Error(msg.error));
+			}
+			return;
+		}
+		try {
+			
+			function invokeCb(cbId, args) {
+				
+				return new Promise((resolve, reject) => {
+					callbackResults.set(cbId, { resolve, reject });
+					parentPort.postMessage({ t: "callback", cb: cbId, args });
+				});
+			}
+			if (msg.t === "call") {
+				
+				
+				if (Array.isArray(msg.path) && msg.path.length === 1 && msg.path[0] === "describe") {
+					function serialize(x) {
+						if (typeof x === "function") {
+							const props = {};
+							for (const k of Object.keys(x)) props[k] = serialize(x[k]);
+							return { __fn: x.name || "", props };
+						}
+						if (x && typeof x === "object") {
+							if (Array.isArray(x)) return x.map(serialize);
+							const out = {};
+							for (const [k, v] of Object.entries(x)) out[k] = serialize(v);
+							return out;
+						}
+						return x;
+					}
+					parentPort.postMessage({ id: msg.id, ok: 1, result: serialize(globalThis.self) });
+					return;
+					
+					
+					
+				}
+				const revivedArgs = reviveArgsReplaceTokens(msg.args || [], invokeCb);
+				
+				
+				let target = globalThis.self;
+				if (Array.isArray(msg.path)) {
+					for (const seg of msg.path) {
+						if (target == null) break;
+						target = target[seg];
+					}
+				}
+				let result;
+				if (typeof target === "function") {
+					
+					result = await target(...revivedArgs);
+				} else if (target && typeof target === "object" && typeof target.default === "function") {
+					
+					result = await target.default(...revivedArgs);
+				} else {
+					throw new TypeError("Resolved value is not a function");
+				}
+				
+				parentPort.postMessage({ id: msg.id, ok: 1, result });
+			} else if (msg.t === "batch") {
+				
+				const revivedOps = Array.isArray(msg.ops)
+					? msg.ops.map((op) => ({ ...op, args: reviveArgsReplaceTokens(op.args || [], invokeCb) }))
+					: msg.ops;
+				
+				const result = await globalThis._portal.batch(revivedOps);
+				
+				parentPort.postMessage({ id: msg.id, ok: 1, result });
+			} else if (msg.t === "dispose") {
+				
+				parentPort.postMessage({ id: msg.id, ok: 1, result: true });
+				
+				
+				
+				
+				
+			}
+		} catch (e) {
+			parentPort.postMessage({ id: msg.id, ok: 0, error: String(e?.stack || e) });
+		}
+	});
+})().catch((e) => {
+	parentPort.postMessage({ id: 0, ok: 0, error: String(e?.stack || e) });
+});