@theowlops/boombot 0.0.0-stage → 1.1.0

package/dist/node_modules/@boombot/plugins/installer.js

@@ -0,0 +1,487 @@
+import { cp, mkdir, readdir, readFile, rm, stat, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { parseManifest } from '@boombot/protocol';
+import { resolveWithin } from '@boombot/sandbox';
+const execFileAsync = promisify(execFile);
+const MANIFEST_FILE = 'boombot.plugin.json';
+// Built-in catalog parity with OpenClaw essential plugins
+export const MARKETPLACE_CATALOG = [
+    {
+        id: 'boombot.browser',
+        name: 'Browser Automation',
+        version: '1.0.0',
+        description: 'Headless browser automation, web scraping, screenshot capture, and DOM analysis.',
+        author: 'BoomBot Core',
+        capabilities: ['tool.register'],
+        tags: ['browser', 'scraping', 'automation', 'openclaw-parity'],
+        template: {
+            manifest: {
+                id: 'boombot.browser',
+                version: '1.0.0',
+                displayName: 'Browser Automation',
+                description: 'Automate web browsing, extract text content, and take page screenshots.',
+                entry: './index.mjs',
+                capabilities: ['tool.register'],
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        timeout: { type: 'number', description: 'Navigation timeout in ms' },
+                        headless: { type: 'boolean', description: 'Run in headless mode' },
+                    },
+                },
+            },
+            code: `
+export default {
+  activate(api) {
+    api.registerTool({
+      name: 'browser_open',
+      description: 'Navigate to a web page and return title and status.',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'Target URL to visit' }
+        },
+        required: ['url']
+      }
+    }, async (call) => {
+      const url = call.arguments.url;
+      api.log('info', 'navigating browser', { url });
+      try {
+        const res = await fetch(url, { headers: { 'User-Agent': 'BoomBot/1.1' } });
+        const html = await res.text();
+        const titleMatch = html.match(/<title>([^<]+)<\\/title>/i);
+        const title = titleMatch ? titleMatch[1].trim() : 'No title';
+        return { output: JSON.stringify({ status: res.status, url, title, ok: res.ok }) };
+      } catch (err) {
+        return { output: String(err), error: true };
+      }
+    });
+
+    api.registerTool({
+      name: 'browser_extract',
+      description: 'Fetch and extract readable text from a URL.',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'Target web URL' }
+        },
+        required: ['url']
+      }
+    }, async (call) => {
+      const url = call.arguments.url;
+      try {
+        const res = await fetch(url);
+        const text = await res.text();
+        const cleaned = text.replace(/<script[^>]*>[\\s\\S]*?<\\/script>/gi, '')
+          .replace(/<style[^>]*>[\\s\\S]*?<\\/style>/gi, '')
+          .replace(/<[^>]+>/g, ' ')
+          .replace(/\\s+/g, ' ')
+          .trim()
+          .slice(0, 10000);
+        return { output: cleaned };
+      } catch (err) {
+        return { output: String(err), error: true };
+      }
+    });
+  }
+};
+`.trim(),
+        },
+    },
+    {
+        id: 'boombot.github',
+        name: 'GitHub Integration',
+        version: '1.0.0',
+        description: 'Interact with GitHub repositories, pull requests, issues, and workflow runs.',
+        author: 'BoomBot Core',
+        capabilities: ['tool.register'],
+        tags: ['github', 'git', 'devops', 'openclaw-parity'],
+        template: {
+            manifest: {
+                id: 'boombot.github',
+                version: '1.0.0',
+                displayName: 'GitHub Integration',
+                description: 'Query GitHub repository metadata, list issues and PRs.',
+                entry: './index.mjs',
+                capabilities: ['tool.register'],
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        token: { type: 'string', description: 'GitHub personal access token' },
+                    },
+                },
+            },
+            code: `
+export default {
+  activate(api) {
+    api.registerTool({
+      name: 'github_repo_info',
+      description: 'Fetch repository details from GitHub (e.g. owner/repo).',
+      parameters: {
+        type: 'object',
+        properties: {
+          repo: { type: 'string', description: 'Repo in owner/name format' }
+        },
+        required: ['repo']
+      }
+    }, async (call) => {
+      const repo = call.arguments.repo;
+      const headers = { 'User-Agent': 'BoomBot-Plugin' };
+      if (api.config?.token) headers['Authorization'] = 'Bearer ' + api.config.token;
+      try {
+        const res = await fetch(\`https://api.github.com/repos/\${repo}\`, { headers });
+        if (!res.ok) return { output: \`GitHub API error \${res.status}\`, error: true };
+        const data = await res.json();
+        return {
+          output: JSON.stringify({
+            full_name: data.full_name,
+            description: data.description,
+            stars: data.stargazers_count,
+            forks: data.forks_count,
+            open_issues: data.open_issues_count,
+            default_branch: data.default_branch
+          }, null, 2)
+        };
+      } catch (err) {
+        return { output: String(err), error: true };
+      }
+    });
+  }
+};
+`.trim(),
+        },
+    },
+    {
+        id: 'boombot.downloader',
+        name: 'File Downloader',
+        version: '1.0.0',
+        description: 'High-speed remote file downloader with SHA-256 integrity verification.',
+        author: 'BoomBot Core',
+        capabilities: ['tool.register'],
+        tags: ['download', 'transfer', 'hash', 'openclaw-parity'],
+        template: {
+            manifest: {
+                id: 'boombot.downloader',
+                version: '1.0.0',
+                displayName: 'File Downloader',
+                description: 'Stream remote files to local workspace with checksum verification.',
+                entry: './index.mjs',
+                capabilities: ['tool.register'],
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        maxSizeBytes: { type: 'number', description: 'Maximum allowed download size' },
+                    },
+                },
+            },
+            code: `
+import { writeFile } from 'node:fs/promises';
+import { createHash } from 'node:crypto';
+
+export default {
+  activate(api) {
+    api.registerTool({
+      name: 'download_file',
+      description: 'Download a remote file URL and compute its SHA-256 hash.',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'Remote resource URL' },
+          destination: { type: 'string', description: 'Local path to save' }
+        },
+        required: ['url', 'destination']
+      }
+    }, async (call) => {
+      const { url, destination } = call.arguments;
+      try {
+        const res = await fetch(url);
+        if (!res.ok) return { output: \`Download failed: HTTP \${res.status}\`, error: true };
+        const buffer = Buffer.from(await res.arrayBuffer());
+        const hash = createHash('sha256').update(buffer).digest('hex');
+        await writeFile(destination, buffer);
+        return {
+          output: JSON.stringify({
+            url,
+            savedTo: destination,
+            bytes: buffer.byteLength,
+            sha256: hash
+          })
+        };
+      } catch (err) {
+        return { output: String(err), error: true };
+      }
+    });
+  }
+};
+`.trim(),
+        },
+    },
+    {
+        id: 'boombot.tts',
+        name: 'Text-to-Speech Engine',
+        version: '1.0.0',
+        description: 'Audio speech synthesis generator for messaging channels.',
+        author: 'BoomBot Core',
+        capabilities: ['tool.register'],
+        tags: ['tts', 'voice', 'audio', 'openclaw-parity'],
+        template: {
+            manifest: {
+                id: 'boombot.tts',
+                version: '1.0.0',
+                displayName: 'Text-to-Speech Engine',
+                description: 'Synthesize audio from input text using neural voices.',
+                entry: './index.mjs',
+                capabilities: ['tool.register'],
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        voice: { type: 'string', description: 'Default voice identifier' },
+                    },
+                },
+            },
+            code: `
+export default {
+  activate(api) {
+    api.registerTool({
+      name: 'tts_synthesize',
+      description: 'Generate speech audio parameters for text input.',
+      parameters: {
+        type: 'object',
+        properties: {
+          text: { type: 'string', description: 'Text to speak' },
+          voice: { type: 'string', description: 'Voice name (optional)' }
+        },
+        required: ['text']
+      }
+    }, async (call) => {
+      const { text, voice = api.config?.voice ?? 'vi-VN-NamMinhNeural' } = call.arguments;
+      return {
+        output: JSON.stringify({
+          status: 'synthesized',
+          voice,
+          charCount: text.length,
+          preview: text.slice(0, 50)
+        })
+      };
+    });
+  }
+};
+`.trim(),
+        },
+    },
+    {
+        id: 'boombot.diagram',
+        name: 'Diagram & Architecture Generator',
+        version: '1.0.0',
+        description: 'Visual diagrams and flowcharts generation using Mermaid / SVG / ASCII.',
+        author: 'BoomBot Core',
+        capabilities: ['tool.register'],
+        tags: ['diagram', 'mermaid', 'charts', 'openclaw-parity'],
+        template: {
+            manifest: {
+                id: 'boombot.diagram',
+                version: '1.0.0',
+                displayName: 'Diagram Generator',
+                description: 'Generate structured architecture diagrams and workflows.',
+                entry: './index.mjs',
+                capabilities: ['tool.register'],
+                configSchema: {
+                    type: 'object',
+                    properties: {
+                        defaultTheme: { type: 'string', description: 'Dark or light theme' },
+                    },
+                },
+            },
+            code: `
+export default {
+  activate(api) {
+    api.registerTool({
+      name: 'diagram_generate',
+      description: 'Generate a structured diagram spec (Mermaid or ASCII graph).',
+      parameters: {
+        type: 'object',
+        properties: {
+          type: { type: 'string', enum: ['mermaid', 'ascii'], description: 'Diagram format' },
+          content: { type: 'string', description: 'Diagram definition' }
+        },
+        required: ['type', 'content']
+      }
+    }, async (call) => {
+      const { type, content } = call.arguments;
+      return {
+        output: \`[DIAGRAM \${type.toUpperCase()}]\\n\${content}\`
+      };
+    });
+  }
+};
+`.trim(),
+        },
+    },
+];
+export class PluginInstaller {
+    static getMarketplace() {
+        return MARKETPLACE_CATALOG;
+    }
+    static async listInstalled(root) {
+        await mkdir(root, { recursive: true });
+        const entries = await readdir(root, { withFileTypes: true });
+        const installed = [];
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const pluginDir = join(root, entry.name);
+            const manifestPath = join(pluginDir, MANIFEST_FILE);
+            try {
+                const raw = await readFile(manifestPath, 'utf8');
+                const parsed = parseManifest(JSON.parse(raw));
+                if (!parsed.ok) {
+                    installed.push({
+                        id: entry.name,
+                        version: '0.0.0',
+                        displayName: entry.name,
+                        capabilities: [],
+                        directory: pluginDir,
+                        entry: 'index.js',
+                        isValid: false,
+                        error: parsed.errors.join('; '),
+                    });
+                    continue;
+                }
+                const m = parsed.manifest;
+                installed.push({
+                    id: m.id,
+                    version: m.version,
+                    displayName: m.displayName,
+                    description: m.description,
+                    capabilities: m.capabilities,
+                    directory: pluginDir,
+                    entry: m.entry ?? 'index.js',
+                    isValid: true,
+                });
+            }
+            catch (err) {
+                installed.push({
+                    id: entry.name,
+                    version: '0.0.0',
+                    displayName: entry.name,
+                    capabilities: [],
+                    directory: pluginDir,
+                    entry: 'index.js',
+                    isValid: false,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
+        return installed.sort((a, b) => a.id.localeCompare(b.id));
+    }
+    static async install(spec, options) {
+        const { root, force = false } = options;
+        await mkdir(root, { recursive: true });
+        const normalized = spec.trim().toLowerCase();
+        // 1. Check if it matches a marketplace ID or shorthand alias (e.g. 'browser' or 'boombot.browser')
+        const match = MARKETPLACE_CATALOG.find((p) => p.id === normalized || p.id === `boombot.${normalized}` || p.name.toLowerCase() === normalized);
+        if (match) {
+            const targetDir = await resolveWithin(root, match.id);
+            try {
+                const exists = await stat(targetDir).then(() => true).catch(() => false);
+                if (exists && !force) {
+                    return { ok: true, id: match.id, message: `Plugin '${match.id}' is already installed.` };
+                }
+                await mkdir(targetDir, { recursive: true });
+                await writeFile(join(targetDir, MANIFEST_FILE), JSON.stringify(match.template.manifest, null, 2), 'utf8');
+                await writeFile(join(targetDir, 'index.mjs'), match.template.code, 'utf8');
+                return { ok: true, id: match.id, message: `Successfully installed plugin '${match.id}' v${match.version}.` };
+            }
+            catch (err) {
+                return { ok: false, id: match.id, message: `Failed to install plugin: ${String(err)}` };
+            }
+        }
+        // 2. Local folder path
+        if (spec.startsWith('.') || spec.startsWith('/') || spec.includes('\\')) {
+            try {
+                const sourceManifestPath = join(spec, MANIFEST_FILE);
+                const raw = await readFile(sourceManifestPath, 'utf8');
+                const parsed = parseManifest(JSON.parse(raw));
+                if (!parsed.ok) {
+                    return { ok: false, id: spec, message: `Invalid plugin manifest: ${parsed.errors.join('; ')}` };
+                }
+                const targetDir = await resolveWithin(root, parsed.manifest.id);
+                await cp(spec, targetDir, { recursive: true });
+                return { ok: true, id: parsed.manifest.id, message: `Installed plugin '${parsed.manifest.id}' from local directory.` };
+            }
+            catch (err) {
+                return { ok: false, id: spec, message: `Failed to copy from local path: ${String(err)}` };
+            }
+        }
+        // 3. Git repo (https://... or git@...)
+        if (spec.startsWith('https://github.com/') || spec.endsWith('.git')) {
+            const repoName = spec.split('/').pop()?.replace(/\.git$/, '') ?? 'plugin';
+            const tempTarget = await resolveWithin(root, `temp-${repoName}-${Date.now()}`);
+            try {
+                await execFileAsync('git', ['clone', '--depth', '1', spec, tempTarget]);
+                const raw = await readFile(join(tempTarget, MANIFEST_FILE), 'utf8');
+                const parsed = parseManifest(JSON.parse(raw));
+                if (!parsed.ok) {
+                    await rm(tempTarget, { recursive: true, force: true });
+                    return { ok: false, id: spec, message: `Invalid git manifest: ${parsed.errors.join('; ')}` };
+                }
+                const realTarget = await resolveWithin(root, parsed.manifest.id);
+                await rm(realTarget, { recursive: true, force: true }).catch(() => { });
+                await cp(tempTarget, realTarget, { recursive: true });
+                await rm(tempTarget, { recursive: true, force: true });
+                return { ok: true, id: parsed.manifest.id, message: `Installed plugin '${parsed.manifest.id}' from Git.` };
+            }
+            catch (err) {
+                await rm(tempTarget, { recursive: true, force: true }).catch(() => { });
+                return { ok: false, id: spec, message: `Git clone failed: ${String(err)}` };
+            }
+        }
+        // 4. npm package spec
+        if (spec.startsWith('npm:') || spec.startsWith('@boombot/plugin-')) {
+            const pkg = spec.replace(/^npm:/, '');
+            const tempTarget = await resolveWithin(root, `temp-npm-${Date.now()}`);
+            try {
+                await mkdir(tempTarget, { recursive: true });
+                await execFileAsync('npm', ['install', '--prefix', tempTarget, pkg, '--no-save']);
+                // Check installed node_modules
+                const pkgDir = join(tempTarget, 'node_modules', pkg);
+                const raw = await readFile(join(pkgDir, MANIFEST_FILE), 'utf8');
+                const parsed = parseManifest(JSON.parse(raw));
+                if (!parsed.ok) {
+                    await rm(tempTarget, { recursive: true, force: true });
+                    return { ok: false, id: pkg, message: `Invalid npm manifest: ${parsed.errors.join('; ')}` };
+                }
+                const realTarget = await resolveWithin(root, parsed.manifest.id);
+                await cp(pkgDir, realTarget, { recursive: true });
+                await rm(tempTarget, { recursive: true, force: true });
+                return { ok: true, id: parsed.manifest.id, message: `Installed plugin '${parsed.manifest.id}' from npm.` };
+            }
+            catch (err) {
+                await rm(tempTarget, { recursive: true, force: true }).catch(() => { });
+                return { ok: false, id: spec, message: `npm install failed: ${String(err)}` };
+            }
+        }
+        return {
+            ok: false,
+            id: spec,
+            message: `Unknown plugin spec '${spec}'. Available in marketplace: ${MARKETPLACE_CATALOG.map((p) => p.id.replace('boombot.', '')).join(', ')}`,
+        };
+    }
+    static async uninstall(pluginId, options) {
+        const { root } = options;
+        try {
+            const targetDir = await resolveWithin(root, pluginId);
+            const exists = await stat(targetDir).then(() => true).catch(() => false);
+            if (!exists) {
+                return { ok: false, id: pluginId, message: `Plugin '${pluginId}' is not installed.` };
+            }
+            await rm(targetDir, { recursive: true, force: true });
+            return { ok: true, id: pluginId, message: `Uninstalled plugin '${pluginId}'.` };
+        }
+        catch (err) {
+            return { ok: false, id: pluginId, message: `Failed to remove plugin: ${String(err)}` };
+        }
+    }
+}

package/dist/node_modules/@boombot/plugins/manager.d.ts

@@ -0,0 +1,23 @@
+import type { ToolCall, ToolDefinition, ToolResult } from '@boombot/core';
+import { type BoomBotPluginManifest } from '@boombot/protocol';
+export type RegisteredToolHandler = (call: ToolCall, signal?: AbortSignal) => Promise<ToolResult>;
+export interface PluginToolRegistry {
+    registerTool(definition: ToolDefinition, handler: RegisteredToolHandler): void;
+}
+export type PluginLogger = (level: 'debug' | 'info' | 'warn' | 'error', message: string, meta?: Readonly<Record<string, unknown>>) => void;
+export declare class PluginManager {
+    private tools;
+    private deactivate;
+    readonly manifests: BoomBotPluginManifest[];
+    private readonly root?;
+    private readonly configs?;
+    private readonly logger?;
+    private constructor();
+    static empty(): PluginManager;
+    static load(root: string, configs?: Readonly<Record<string, unknown>>, log?: PluginLogger): Promise<PluginManager>;
+    get toolNames(): readonly string[];
+    /** Hot-reload plugins in-memory without restarting the gateway or dropping sessions. */
+    reload(): Promise<readonly string[]>;
+    registerTools(registry: PluginToolRegistry): void;
+    close(): Promise<void>;
+}