219 lines
9.0 KiB
JavaScript
219 lines
9.0 KiB
JavaScript
const fs = require("fs");
|
|
const path = require("path");
|
|
const { resolveData } = require("./paths");
|
|
const { registerManagedTool } = require("./tool_registry");
|
|
|
|
class ToolLoader {
|
|
constructor(options = {}) {
|
|
this.registry = options.registry;
|
|
this.installer = options.installer;
|
|
this.settings = options.settings;
|
|
this.lumiAiVersion = options.lumiAiVersion || "0.0.0";
|
|
this.lumiVersion = options.lumiVersion || "0.0.0";
|
|
this.stateFile = options.stateFile || resolveData("tools", "enabled.json");
|
|
this.loaded = new Map();
|
|
this.statuses = new Map();
|
|
}
|
|
|
|
async loadEnabled() {
|
|
const state = this.readState();
|
|
for (const local of this.installer.scanLocal()) {
|
|
if (state.enabled[local.tool_id] === true) {
|
|
try { await this.enable(local.tool_id, { persist: false }); }
|
|
catch (error) { this.setStatus(local.tool_id, "unavailable", error.message); }
|
|
}
|
|
}
|
|
}
|
|
|
|
async enable(toolId, options = {}) {
|
|
const local = this.installer.local(toolId);
|
|
if (!local?.valid) throw new Error(local?.error || "Installed AI tool metadata is invalid.");
|
|
const dependencies = this.inspectDependencies(local.metadata, local.dir);
|
|
if (dependencies.blocking.length) {
|
|
const message = `Unavailable: ${dependencies.blocking.join("; ")}`;
|
|
this.setStatus(toolId, "unavailable", message, dependencies);
|
|
if (options.persist !== false) this.setEnabled(toolId, true);
|
|
return { loaded: false, unavailable: true, message, dependencies };
|
|
}
|
|
await this.disable(toolId, { persist: false });
|
|
const backend = backendEntrypoint(local.metadata, local.dir);
|
|
const registered = [];
|
|
let cleanup = null;
|
|
if (backend) {
|
|
clearRequireCache(local.dir);
|
|
try {
|
|
const module = require(backend);
|
|
const register = module?.register || module?.init;
|
|
if (typeof register !== "function") throw new Error("Backend entrypoint must export register() or init().");
|
|
const context = {
|
|
metadata: Object.freeze({ ...local.metadata }),
|
|
registerTool: (definition) => {
|
|
const unregister = registerManagedTool(this.registry, local.metadata, definition);
|
|
registered.push({ id: definition.tool_id, unregister });
|
|
return unregister;
|
|
},
|
|
paths: Object.freeze({
|
|
root: local.dir,
|
|
data: path.join(local.dir, "data"),
|
|
config: path.join(local.dir, "config")
|
|
}),
|
|
assetUrl: (relative = "") => `/plugins/lumi_ai/tools/${toolId}/assets/${String(relative).replace(/^\/+/, "")}`
|
|
};
|
|
if (typeof module.checkAvailability === "function") {
|
|
const availability = await module.checkAvailability(context);
|
|
if (availability?.available === false) {
|
|
this.loaded.set(toolId, { cleanup: null, registered, metadata: local.metadata, dir: local.dir });
|
|
this.setStatus(toolId, "unavailable", String(availability.message || "Tool configuration is incomplete."), dependencies);
|
|
if (options.persist !== false) this.setEnabled(toolId, true);
|
|
return { loaded: false, unavailable: true, message: availability.message, dependencies };
|
|
}
|
|
}
|
|
const result = await register(context);
|
|
cleanup = typeof result === "function" ? result : typeof result?.stop === "function" ? () => result.stop() : null;
|
|
} catch (error) {
|
|
this.registry.unregisterOwner(toolId);
|
|
this.setStatus(toolId, "unavailable", error.message, dependencies);
|
|
if (options.persist !== false) this.setEnabled(toolId, true);
|
|
return { loaded: false, unavailable: true, message: error.message, dependencies };
|
|
}
|
|
}
|
|
this.loaded.set(toolId, { cleanup, registered, metadata: local.metadata, dir: local.dir });
|
|
this.setStatus(toolId, "enabled", dependencies.optional.length ? `Enabled with limitations: ${dependencies.optional.join("; ")}` : "", dependencies);
|
|
if (options.persist !== false) this.setEnabled(toolId, true);
|
|
return { loaded: true, registered: registered.map((entry) => entry.id), dependencies };
|
|
}
|
|
|
|
async disable(toolId, options = {}) {
|
|
const loaded = this.loaded.get(toolId);
|
|
if (loaded) {
|
|
try { await loaded.cleanup?.(); } catch {}
|
|
this.registry.unregisterOwner(toolId);
|
|
this.loaded.delete(toolId);
|
|
} else {
|
|
this.registry.unregisterOwner(toolId);
|
|
}
|
|
if (options.persist !== false) this.setEnabled(toolId, false);
|
|
this.setStatus(toolId, "disabled", "");
|
|
return { disabled: true };
|
|
}
|
|
|
|
async stopAll() {
|
|
for (const toolId of [...this.loaded.keys()]) await this.disable(toolId, { persist: false });
|
|
}
|
|
|
|
isEnabled(toolId) {
|
|
return this.readState().enabled[toolId] === true;
|
|
}
|
|
|
|
status(toolId) {
|
|
return this.statuses.get(toolId) || { state: this.isEnabled(toolId) ? "pending" : "disabled", message: "" };
|
|
}
|
|
|
|
inspectDependencies(metadata, toolDir) {
|
|
const blocking = [];
|
|
const optional = [];
|
|
for (const pluginId of metadata.required_plugins || []) {
|
|
if (/^lumi_ai_.+/i.test(pluginId)) {
|
|
blocking.push(`AI tool plugins cannot depend on AI tool plugin ${pluginId}`);
|
|
} else if (!["core", "lumi_ai"].includes(pluginId) && !fs.existsSync(path.resolve(toolDir, "..", pluginId))) {
|
|
blocking.push(`required plugin ${pluginId} is missing`);
|
|
}
|
|
}
|
|
for (const platform of metadata.required_platforms || []) {
|
|
if (this.settings?.getSetting?.(`platform_${platform}_enabled`, false) !== true) {
|
|
blocking.push(`required platform ${platform} is disabled`);
|
|
}
|
|
}
|
|
for (const dependency of metadata.dependencies || []) {
|
|
try { require.resolve(dependency, { paths: [toolDir] }); }
|
|
catch { optional.push(`optional dependency ${dependency} is missing`); }
|
|
}
|
|
if (metadata.minimum_lumi_ai_version && compareVersions(this.lumiAiVersion, metadata.minimum_lumi_ai_version) < 0) {
|
|
blocking.push(`requires Lumi AI ${metadata.minimum_lumi_ai_version}`);
|
|
}
|
|
if (metadata.minimum_lumi_version && compareVersions(this.lumiVersion, metadata.minimum_lumi_version) < 0) {
|
|
blocking.push(`requires Lumi ${metadata.minimum_lumi_version}`);
|
|
}
|
|
return { blocking, optional };
|
|
}
|
|
|
|
resolveAsset(toolId, relative) {
|
|
const loaded = this.loaded.get(toolId);
|
|
if (!loaded || !this.isEnabled(toolId)) return null;
|
|
const roots = assetRoots(loaded.metadata, loaded.dir);
|
|
for (const root of roots) {
|
|
const candidate = path.resolve(root, String(relative || ""));
|
|
if ((candidate === root || candidate.startsWith(`${root}${path.sep}`)) && fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
|
|
return candidate;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
setStatus(toolId, state, message, dependencies = null) {
|
|
this.statuses.set(toolId, { state, message: String(message || ""), dependencies });
|
|
}
|
|
|
|
readState() {
|
|
try {
|
|
const value = JSON.parse(fs.readFileSync(this.stateFile, "utf8"));
|
|
return { enabled: value.enabled && typeof value.enabled === "object" ? value.enabled : {} };
|
|
} catch {
|
|
return { enabled: {} };
|
|
}
|
|
}
|
|
|
|
setEnabled(toolId, enabled) {
|
|
const state = this.readState();
|
|
state.enabled[toolId] = Boolean(enabled);
|
|
fs.mkdirSync(path.dirname(this.stateFile), { recursive: true });
|
|
const temporary = `${this.stateFile}.${process.pid}.tmp`;
|
|
fs.writeFileSync(temporary, `${JSON.stringify(state, null, 2)}\n`);
|
|
fs.renameSync(temporary, this.stateFile);
|
|
}
|
|
}
|
|
|
|
function backendEntrypoint(metadata, toolDir) {
|
|
const configured = typeof metadata.entrypoints === "string"
|
|
? metadata.entrypoints
|
|
: metadata.entrypoints?.backend;
|
|
const relative = configured || (fs.existsSync(path.join(toolDir, "index.js")) ? "index.js" : "");
|
|
if (!relative) return null;
|
|
const target = path.resolve(toolDir, relative);
|
|
if (!target.startsWith(`${path.resolve(toolDir)}${path.sep}`) || !fs.existsSync(target)) {
|
|
throw new Error("Backend entrypoint is missing or unsafe.");
|
|
}
|
|
return target;
|
|
}
|
|
|
|
function assetRoots(metadata, toolDir) {
|
|
const entries = Array.isArray(metadata.frontend_assets)
|
|
? metadata.frontend_assets
|
|
: metadata.frontend_assets ? [metadata.frontend_assets] : ["public"];
|
|
return entries.map((entry) => path.resolve(toolDir, entry))
|
|
.filter((entry) => entry.startsWith(`${path.resolve(toolDir)}${path.sep}`) && fs.existsSync(entry));
|
|
}
|
|
|
|
function clearRequireCache(directory) {
|
|
const prefix = `${path.resolve(directory)}${path.sep}`;
|
|
for (const key of Object.keys(require.cache)) if (key.startsWith(prefix)) delete require.cache[key];
|
|
}
|
|
|
|
function compareVersions(left, right) {
|
|
const parse = (value) => String(value || "0.0.0").split(/[+-]/)[0].split(".").map((part) => Number.parseInt(part, 10) || 0);
|
|
const a = parse(left);
|
|
const b = parse(right);
|
|
for (let index = 0; index < Math.max(a.length, b.length, 3); index += 1) {
|
|
if ((a[index] || 0) !== (b[index] || 0)) return (a[index] || 0) > (b[index] || 0) ? 1 : -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
module.exports = {
|
|
ToolLoader,
|
|
assetRoots,
|
|
backendEntrypoint,
|
|
clearRequireCache,
|
|
compareVersions
|
|
};
|