manyplug 1.3.0

package/src/install.js

@@ -0,0 +1,204 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { execSync } from 'node:child_process';
+import { formatSize } from './ui.js';
+import { loadLocalRegistry, saveRegistry, fetchRemoteRegistry } from './registry-ops.js';
+import { getDirSize, installPluginFromRepo, installNpmDeps } from './utils.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PLUGINS_DIR = path.join(process.cwd(), 'src', 'plugins');
+
+// ------------------------------------------------------------
+// helpers
+// ------------------------------------------------------------
+
+function onMirror(mirror, status, err) {
+	console.log(`  ${status === 'ok' ? '+' : 'x'} ${mirror.name}${err ? ': ' + err : ''}`);
+}
+
+function commandExists(cmd) {
+	try {
+		const check = process.platform === 'win32' ? `where ${cmd}` : `command -v ${cmd}`;
+		execSync(check, { stdio: 'pipe' });
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+// Returns { missing: [], optional: [] } based on manifest.externalDependencies
+function checkExternalDeps(manifest) {
+	const ext = manifest.externalDependencies;
+	if (!ext || !Object.keys(ext).length) return { missing: [], optional: [] };
+
+	const missing = [], optional = [];
+
+	for (const [name, cfg] of Object.entries(ext)) {
+		if (commandExists(typeof cfg === 'string' ? cfg : cfg.command)) continue;
+		(cfg?.optional ? optional : missing).push(name);
+	}
+
+	return { missing, optional };
+}
+
+function reportExternalDeps(manifest) {
+	const { missing, optional } = checkExternalDeps(manifest);
+	if (missing.length)   console.warn(`warn: missing external deps: ${missing.join(', ')}`);
+	if (optional.length)  console.log(`info: optional deps not found: ${optional.join(', ')}`);
+	return { missing, optional };
+}
+
+async function installDeps(manifest, targetDir) {
+	const deps = manifest.dependencies;
+	if (!deps || !Object.keys(deps).length) return;
+	console.log('  installing npm deps...');
+	await installNpmDeps(deps, targetDir);
+}
+
+async function registerPlugin(pluginName, manifest, extra = {}) {
+	const registry = await loadLocalRegistry();
+	registry.plugins[pluginName] = { ...manifest, ...extra };
+	await saveRegistry(registry);
+}
+
+// ------------------------------------------------------------
+// install from local path
+// ------------------------------------------------------------
+
+async function installFromLocal(sourcePath) {
+	const src = path.resolve(sourcePath);
+
+	if (!await fs.pathExists(src))
+		return { success: false, error: `path not found: ${src}` };
+
+	const manifestPath = path.join(src, 'manyplug.json');
+	if (!await fs.pathExists(manifestPath))
+		return { success: false, error: 'manyplug.json not found' };
+
+	let manifest;
+	try { manifest = await fs.readJson(manifestPath); }
+	catch (e) { return { success: false, error: `invalid manyplug.json: ${e.message}` }; }
+
+	const name = manifest.name || path.basename(src);
+	const dest = path.join(PLUGINS_DIR, name);
+
+	if (await fs.pathExists(dest))
+		return { success: false, error: `${name} already installed` };
+
+	const size = await getDirSize(src);
+	console.log(`installing ${name}  src=${src}  size=${formatSize(size)}`);
+	reportExternalDeps(manifest);
+
+	try {
+		await fs.ensureDir(PLUGINS_DIR);
+		await fs.copy(src, dest);
+		await installDeps(manifest, dest);
+		await registerPlugin(name, manifest, { local: true });
+		return { success: true, plugin: name, size };
+	} catch (e) {
+		return { success: false, error: e.message, plugin: name };
+	}
+}
+
+// ------------------------------------------------------------
+// install single plugin from remote registry
+// ------------------------------------------------------------
+
+async function installFromRegistry(pluginName, manifest, mirror) {
+	const t = Date.now();
+	const dest = path.join(PLUGINS_DIR, pluginName);
+
+	try {
+		const { size } = await installPluginFromRepo({ plugin: pluginName, repo: mirror }, PLUGINS_DIR);
+		await installDeps(manifest, dest);
+		await registerPlugin(pluginName, manifest);
+		return { success: true, plugin: pluginName, size, duration: Date.now() - t };
+	} catch (e) {
+		return { success: false, error: e.message, plugin: pluginName };
+	}
+}
+
+// ------------------------------------------------------------
+// install command (entry point)
+// ------------------------------------------------------------
+
+export async function installCommand(pluginsInput, options = {}) {
+	const t = Date.now();
+	const names = Array.isArray(pluginsInput) ? pluginsInput : (pluginsInput ? [pluginsInput] : []);
+
+	await fs.ensureDir(PLUGINS_DIR);
+
+	// -- local install --
+	if (options.local) {
+		const r = await installFromLocal(options.local);
+		if (!r.success) { console.error(r.error); process.exit(1); }
+		console.log(`installed ${r.plugin}  size=${formatSize(r.size)}  time=${elapsed(t)}s`);
+		return;
+	}
+
+	if (!names.length) { console.error('usage: manyplug install <plugin>'); process.exit(1); }
+
+	// -- fetch remote registry --
+	process.stdout.write('fetching registry... ');
+	let remoteRegistry, mirror;
+	try {
+		({ remoteRegistry, selectedMirror: mirror } = await fetchRemoteRegistry(onMirror));
+		mirror = mirror.git;
+		console.log('ok');
+	} catch (e) {
+		console.error(`failed: ${e.message}`);
+		process.exit(1);
+	}
+
+	// -- classify plugins --
+	const toInstall = [], toReinstall = [], notFound = [];
+
+	for (const name of names) {
+		const manifest = remoteRegistry.plugins[name];
+		if (!manifest) { notFound.push(name); continue; }
+
+		const installed = await fs.pathExists(path.join(PLUGINS_DIR, name));
+		const entry = { name, version: manifest.version, manifest };
+
+		if (installed && !options.needed) toReinstall.push(entry);
+		else if (!installed)             toInstall.push(entry);
+		// installed + --needed => skip (nothing pushed)
+	}
+
+	if (notFound.length) console.error(`not found: ${notFound.join(', ')}`);
+
+	const queue = [...toInstall, ...toReinstall];
+	if (!queue.length) { console.log('nothing to do'); process.exit(0); }
+
+	// -- print plan --
+	for (const p of toInstall)    console.log(`+ ${p.name}@${p.version}`);
+	for (const p of toReinstall)  console.log(`~ ${p.name}@${p.version} (reinstall)`);
+
+	// -- remove stale installs --
+	for (const p of toReinstall) {
+		await fs.remove(path.join(PLUGINS_DIR, p.name));
+		const registry = await loadLocalRegistry();
+		delete registry.plugins[p.name];
+		await saveRegistry(registry);
+	}
+
+	// -- run queue --
+	const results = [];
+	for (const p of queue) {
+		process.stdout.write(`installing ${p.name}... `);
+		const r = await installFromRegistry(p.name, p.manifest, mirror);
+		results.push(r);
+		console.log(r.success ? 'done' : `FAILED${r.error ? ': ' + r.error : ''}`);
+	}
+
+	// -- summary --
+	const ok  = results.filter(r => r.success).length;
+	const bad = results.length - ok;
+	console.log(`\n${ok}/${results.length} installed in ${elapsed(t)}s`);
+	if (bad) process.exit(1);
+}
+
+// ------------------------------------------------------------
+
+function elapsed(since) { return ((Date.now() - since) / 1000).toFixed(2); }

package/src/list.js

@@ -0,0 +1,90 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { existsSync, readFileSync } from 'fs';
+
+const CONF_PATH   = path.resolve(process.cwd(), 'manybot.conf');
+const PLUGINS_DIR = path.join(process.cwd(), 'src', 'plugins');
+
+// ------------------------------------------------------------
+// conf — reuse same parser as enable-disable reads
+// ------------------------------------------------------------
+
+function readEnabled() {
+	if (!existsSync(CONF_PATH)) return new Set();
+	const match = readFileSync(CONF_PATH, 'utf-8').match(/PLUGINS=\[\s*([\s\S]*?)\s*\]/);
+	if (!match) return new Set();
+	return new Set(match[1].split(',').map(s => s.trim().toLowerCase()).filter(Boolean));
+}
+
+// ------------------------------------------------------------
+// list command
+// ------------------------------------------------------------
+
+export async function listCommand(options = {}) {
+	if (!await fs.pathExists(PLUGINS_DIR)) {
+		console.error(`error: plugins dir not found: ${PLUGINS_DIR}`);
+		return;
+	}
+
+	const enabled = readEnabled();
+	const entries = (await fs.readdir(PLUGINS_DIR, { withFileTypes: true })).filter(e => e.isDirectory());
+	const plugins = [];
+
+	for (const entry of entries) {
+		const dir          = path.join(PLUGINS_DIR, entry.name);
+		const manifestPath = path.join(dir, 'manyplug.json');
+		const hasEntry     = await fs.pathExists(path.join(dir, 'index.js'));
+		const isEnabled    = enabled.has(entry.name.toLowerCase());
+
+		if (!isEnabled && !options.all) continue;
+
+		let manifest = {};
+		try { manifest = await fs.readJson(manifestPath); }
+		catch { manifest = { name: entry.name, version: '?', category: '?', _error: true }; }
+
+		plugins.push({
+			name:     manifest.name || entry.name,
+			version:  manifest.version || '-',
+			category: manifest.category || '-',
+			service:  manifest.service === true,
+			local:    manifest.local   === true,
+			enabled:  isEnabled,
+			hasEntry,
+			_error:   manifest._error || false,
+		});
+	}
+
+	if (!plugins.length) {
+		console.log(options.all ? 'no plugins installed' : 'no enabled plugins  (use --all to see all)');
+		return;
+	}
+
+	// column widths
+	const w = {
+		name:     Math.max(4, ...plugins.map(p => p.name.length)),
+		version:  Math.max(7, ...plugins.map(p => p.version.length)),
+		category: Math.max(8, ...plugins.map(p => p.category.length)),
+	};
+
+	const pad = (s, n) => s.padEnd(n);
+	const header = `  ${'name'.padEnd(w.name)}  ${'version'.padEnd(w.version)}  ${'category'.padEnd(w.category)}  type  status`;
+	console.log(header);
+	console.log('  ' + '-'.repeat(header.length - 2));
+
+	for (const p of plugins) {
+		const flag   = p.local ? 'L' : p._error ? '!' : ' ';
+		const type   = p.service ? 'svc' : 'std';
+		const status = !p.hasEntry ? 'incomplete' : p.enabled ? 'enabled' : 'disabled';
+		console.log(`${flag} ${pad(p.name, w.name)}  ${pad(p.version, w.version)}  ${pad(p.category, w.category)}  ${pad(type, 4)}  ${status}`);
+	}
+
+	// summary
+	const en   = plugins.filter(p => p.enabled).length;
+	const dis  = plugins.length - en;
+	const loc  = plugins.filter(p => p.local).length;
+	const inc  = plugins.filter(p => !p.hasEntry).length;
+
+	console.log('');
+	console.log(`total=${plugins.length} enabled=${en} disabled=${dis}${loc ? ' local=' + loc : ''}${inc ? ' incomplete=' + inc : ''}`);
+	console.log('L=local  svc=service  std=standard  !=missing index.js');
+}

package/src/registry-ops.js

@@ -0,0 +1,45 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REGISTRY_PATH = path.join(process.cwd(), 'registry.json');
+const CONFIG_PATH   = path.join(__dirname, '..', 'config.json');
+
+// ------------------------------------------------------------
+
+function loadConfig() {
+	try { return fs.readJsonSync(CONFIG_PATH); }
+	catch (e) { console.error(`error: config.json: ${e.message}`); process.exit(1); }
+}
+
+export const MIRRORS = loadConfig().mirrors;
+
+// ------------------------------------------------------------
+
+export async function loadLocalRegistry() {
+	try { return await fs.readJson(REGISTRY_PATH); }
+	catch { return { lastUpdated: null, plugins: {} }; }
+}
+
+export async function saveRegistry(registry) {
+	registry.lastUpdated = new Date().toISOString();
+	await fs.writeJson(REGISTRY_PATH, registry, { spaces: 2 });
+}
+
+// ------------------------------------------------------------
+
+// onMirror(mirror, 'ok'|'fail', errMsg?) — optional progress callback
+export async function fetchRemoteRegistry(onMirror = () => {}) {
+	for (const mirror of MIRRORS) {
+		try {
+			const res = await fetch(`${mirror.fetch}/registry.json`);
+			if (!res.ok) throw new Error(`HTTP ${res.status}`);
+			onMirror(mirror, 'ok');
+			return { remoteRegistry: await res.json(), selectedMirror: mirror };
+		} catch (e) {
+			onMirror(mirror, 'fail', e.message);
+		}
+	}
+	throw new Error('all mirrors failed');
+}

package/src/remove.js

@@ -0,0 +1,114 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { exec } from 'node:child_process';
+import { formatSize } from './ui.js';
+import { loadLocalRegistry, saveRegistry } from './registry-ops.js';
+
+const PLUGINS_DIR = path.join(process.cwd(), 'src', 'plugins');
+
+// ------------------------------------------------------------
+// helpers
+// ------------------------------------------------------------
+
+function elapsed(since) { return ((Date.now() - since) / 1000).toFixed(2); }
+
+function run(cmd, cwd) {
+	return new Promise((res, rej) =>
+		exec(cmd, { cwd }, (err, stdout) => err ? rej(err) : res(stdout))
+	);
+}
+
+async function getDirSize(dir) {
+	let total = 0;
+	for (const entry of await fs.readdir(dir, { withFileTypes: true })) {
+		const p = path.join(dir, entry.name);
+		total += entry.isDirectory() ? await getDirSize(p) : (await fs.stat(p)).size;
+	}
+	return total;
+}
+
+async function ask(prompt) {
+	process.stdout.write(prompt);
+	return new Promise(res => process.stdin.once('data', d => res(d.toString().trim().toLowerCase())));
+}
+
+// ------------------------------------------------------------
+// remove command
+// ------------------------------------------------------------
+
+export async function removeCommand(input, options = {}) {
+	const t     = Date.now();
+	const names = Array.isArray(input) ? input : (input ? [input] : []);
+
+	if (!names.length) {
+		console.error('usage: manyplug remove <plugin> [plugin2...]');
+		process.exit(1);
+	}
+
+	const results = [];
+
+	for (const name of names) {
+		const dir          = path.join(PLUGINS_DIR, name);
+		const manifestPath = path.join(dir, 'manyplug.json');
+
+		if (!await fs.pathExists(manifestPath)) {
+			console.error(`x ${name}: not installed`);
+			results.push({ name, success: false });
+			continue;
+		}
+
+		let manifest = {};
+		try { manifest = await fs.readJson(manifestPath); } catch {}
+
+		const size = await getDirSize(dir);
+		const deps = manifest.dependencies || {};
+		const hasDeps = Object.keys(deps).length > 0;
+
+		console.log(`- ${name}@${manifest.version || '?'}  size=${formatSize(size)}  path=${path.relative(process.cwd(), dir)}`);
+		if (hasDeps) console.log(`  deps: ${Object.keys(deps).join(', ')}`);
+
+		if (!options.yes) {
+			const answer = await ask('remove? [y/N] ');
+			if (answer !== 'y') {
+				console.log(`  skipped`);
+				results.push({ name, success: false, skipped: true });
+				continue;
+			}
+		}
+
+		try {
+			await fs.remove(dir);
+
+			const registry = await loadLocalRegistry();
+			delete registry.plugins[name];
+			await saveRegistry(registry);
+
+			if (hasDeps && options.removeDeps) {
+				process.stdout.write(`  uninstalling npm deps... `);
+				try {
+					await run(`npm uninstall ${Object.keys(deps).join(' ')}`, process.cwd());
+					console.log('ok');
+				} catch (e) {
+					console.log(`warn: ${e.message}`);
+				}
+			}
+
+			console.log(`  done  freed=${formatSize(size)}`);
+			results.push({ name, success: true, size });
+		} catch (e) {
+			console.error(`  FAILED: ${e.message}`);
+			results.push({ name, success: false, error: e.message });
+		}
+	}
+
+	// summary
+	const ok      = results.filter(r => r.success).length;
+	const bad     = results.length - ok;
+	const freed   = results.reduce((a, r) => a + (r.size || 0), 0);
+
+	if (names.length > 1) {
+		console.log(`\n${ok}/${names.length} removed  freed=${formatSize(freed)}  time=${elapsed(t)}s`);
+	}
+
+	if (bad && !results.every(r => r.skipped)) process.exit(1);
+}

package/src/sync.js

@@ -0,0 +1,179 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { formatSize } from './ui.js';
+import { loadLocalRegistry, saveRegistry, fetchRemoteRegistry } from './registry-ops.js';
+import { installPluginFromRepo, installNpmDeps } from './utils.js';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PLUGINS_DIR = path.join(process.cwd(), 'src', 'plugins');
+
+// ------------------------------------------------------------
+// helpers
+// ------------------------------------------------------------
+
+function elapsed(since) { return ((Date.now() - since) / 1000).toFixed(2); }
+
+function onMirror(mirror, status, err) {
+	console.log(`  ${status === 'ok' ? '+' : 'x'} ${mirror.name}${err ? ': ' + err : ''}`);
+}
+
+async function fetchRegistry() {
+	process.stdout.write('fetching registry... ');
+	try {
+		const r = await fetchRemoteRegistry(onMirror);
+		console.log('ok');
+		return r;
+	} catch (e) {
+		console.error(`failed: ${e.message}`);
+		process.exit(1);
+	}
+}
+
+async function installDeps(manifest, targetDir) {
+	const deps = manifest.dependencies;
+	if (!deps || !Object.keys(deps).length) return;
+	await installNpmDeps(deps, targetDir);
+}
+
+// ------------------------------------------------------------
+// sync command — reconcile local registry with remote
+// ------------------------------------------------------------
+
+export async function syncCommand(options = {}) {
+	const t = Date.now();
+	const { remoteRegistry, selectedMirror } = await fetchRegistry();
+	const local = await loadLocalRegistry();
+
+	const synced   = {};
+	const added    = [], updated = [], kept = [], localOnly = [], skipped = [];
+
+	// reconcile local plugins against remote
+	for (const [name, lm] of Object.entries(local.plugins || {})) {
+		if (lm.local) {
+			localOnly.push(name);
+			synced[name] = lm;
+			continue;
+		}
+		const rm = remoteRegistry.plugins?.[name];
+		if (rm && lm.version !== rm.version) {
+			updated.push(`${name} ${lm.version}->${rm.version}`);
+			synced[name] = rm;
+		} else {
+			kept.push(name);
+			synced[name] = lm;
+		}
+	}
+
+	// plugins in remote not installed locally
+	for (const [name, rm] of Object.entries(remoteRegistry.plugins || {})) {
+		if (!local.plugins?.[name]) skipped.push(name);
+	}
+
+	// plugins on disk not in registry
+	if (await fs.pathExists(PLUGINS_DIR)) {
+		for (const entry of await fs.readdir(PLUGINS_DIR, { withFileTypes: true })) {
+			if (!entry.isDirectory() || synced[entry.name]) continue;
+			const mp = path.join(PLUGINS_DIR, entry.name, 'manyplug.json');
+			if (!await fs.pathExists(mp)) continue;
+			try {
+				const manifest = await fs.readJson(mp);
+				added.push(entry.name);
+				synced[entry.name] = manifest;
+			} catch {}
+		}
+	}
+
+	// summary
+	if (added.length)    console.log(`+ added:    ${added.join(', ')}`);
+	if (updated.length)  console.log(`~ updated:  ${updated.join(', ')}`);
+	if (kept.length)     console.log(`= kept:     ${kept.length} plugin(s)`);
+	if (localOnly.length) console.log(`L local:    ${localOnly.join(', ')}`);
+	if (skipped.length)  console.log(`- skipped:  ${skipped.length} not installed`);
+
+	console.log(`  source:  ${selectedMirror.name}`);
+	console.log(`  synced:  ${Object.keys(synced).length} plugin(s)`);
+
+	const hasChanges = added.length || updated.length;
+	if (hasChanges || options.force) {
+		process.stdout.write('saving registry... ');
+		try {
+			await saveRegistry({ plugins: synced });
+			console.log('ok');
+		} catch (e) {
+			console.error(`failed: ${e.message}`);
+			process.exit(1);
+		}
+	}
+
+	console.log(`done in ${elapsed(t)}s`);
+}
+
+// ------------------------------------------------------------
+// update command — install/update all plugins from remote
+// ------------------------------------------------------------
+
+async function applyPlugin(name, manifest, mirror, isUpdate) {
+	const dest = path.join(PLUGINS_DIR, name);
+	process.stdout.write(`${isUpdate ? 'updating' : 'installing'} ${name}... `);
+	try {
+		if (isUpdate && await fs.pathExists(dest)) await fs.remove(dest);
+		const { size } = await installPluginFromRepo({ plugin: name, repo: mirror }, PLUGINS_DIR);
+		await installDeps(manifest, dest);
+		const registry = await loadLocalRegistry();
+		registry.plugins[name] = manifest;
+		await saveRegistry(registry);
+		console.log(`done (${formatSize(size)})`);
+		return { success: true, name, size };
+	} catch (e) {
+		console.log(`FAILED: ${e.message}`);
+		return { success: false, name, error: e.message };
+	}
+}
+
+export async function updateCommand(options = {}) {
+	const t = Date.now();
+	const { remoteRegistry, selectedMirror } = await fetchRegistry();
+	const local = await loadLocalRegistry();
+
+	const toInstall = [], toUpdate = [], localOnly = [];
+
+	for (const [name, rm] of Object.entries(remoteRegistry.plugins || {})) {
+		const onDisk = await fs.pathExists(path.join(PLUGINS_DIR, name));
+		if (!onDisk) continue; // not installed locally, skip
+		const lm = local.plugins?.[name];
+		if (lm?.version !== rm.version) toUpdate.push({ name, manifest: rm, from: lm?.version ?? '?', to: rm.version });
+	}
+	for (const name of Object.keys(local.plugins || {})) {
+		if (!remoteRegistry.plugins?.[name]) localOnly.push(name);
+	}
+
+	// plan
+	for (const p of toUpdate)  console.log(`~ ${p.name} ${p.from}->${p.to}`);
+	if (localOnly.length)      console.log(`L local only (skipped): ${localOnly.join(', ')}`);
+
+	const total = toUpdate.length;
+	if (!total) { console.log(`nothing to do  (${elapsed(t)}s)`); return; }
+
+	// confirm
+	if (!options.yes) {
+		process.stdout.write(`${total} plugin(s) will be updated, continue? [y/N] `);
+		const answer = await new Promise(res => {
+			process.stdin.once('data', d => res(d.toString().trim().toLowerCase()));
+		});
+		if (answer !== 'y') { console.log('cancelled'); process.exit(0); }
+	}
+
+	// run
+	const results = [];
+	const mirror  = selectedMirror.git;
+	for (const p of toUpdate)  results.push(await applyPlugin(p.name, p.manifest, mirror, true));
+
+	// summary
+	const ok  = results.filter(r => r.success).length;
+	const bad = results.length - ok;
+	const totalSize = results.reduce((a, r) => a + (r.size || 0), 0);
+
+	console.log(`\n${ok}/${results.length} updated in ${elapsed(t)}s  size=${formatSize(totalSize)}`);
+	process.exit(1);
+}