openbot 0.4.7 → 0.5.4

package/dist/registry/plugins.js

@@ -1,110 +0,0 @@
-import fs from 'node:fs';
-import path from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { openbotPlugin } from '../plugins/openbot/index.js';
-import { shellPlugin } from '../plugins/shell/index.js';
-import { storageToolsPlugin } from '../plugins/storage-tools/index.js';
-import { uiPlugin } from '../plugins/ui/index.js';
-import { approvalPlugin } from '../plugins/approval/index.js';
-import { memoryPlugin } from '../plugins/memory/index.js';
-import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
-let pluginsDir = null;
-const loadedPlugins = new Set();
-const cache = new Map();
-const BUILT_IN = {
-    [openbotPlugin.id]: openbotPlugin,
-    [shellPlugin.id]: shellPlugin,
-    [storageToolsPlugin.id]: storageToolsPlugin,
-    [uiPlugin.id]: uiPlugin,
-    [approvalPlugin.id]: approvalPlugin,
-    [memoryPlugin.id]: memoryPlugin,
-};
-/** Normalize a dynamically imported plugin module. Supports `plugin`, `default`. */
-export function parsePluginModule(module) {
-    const raw = module.plugin ??
-        module.default;
-    if (!raw || typeof raw !== 'object')
-        return null;
-    const factory = raw.factory;
-    if (typeof factory !== 'function')
-        return null;
-    const name = typeof raw.name === 'string' ? raw.name : '';
-    const description = typeof raw.description === 'string' ? raw.description : '';
-    const image = typeof raw.image === 'string' ? raw.image : undefined;
-    const configSchema = raw.configSchema;
-    const toolDefinitions = raw.toolDefinitions;
-    return {
-        name,
-        description,
-        image,
-        configSchema,
-        toolDefinitions,
-        factory: factory,
-    };
-}
-/** Initialize the on-disk plugins directory (defaults to ~/.openbot/plugins). */
-export function initPlugins(dir) {
-    if (dir) {
-        pluginsDir = dir;
-    }
-    else {
-        const config = loadConfig();
-        const baseDir = config.baseDir || DEFAULT_BASE_DIR;
-        pluginsDir = path.join(resolvePath(baseDir), DEFAULT_PLUGINS_DIR);
-    }
-}
-/**
- * Resolve a Plugin by id. The id is either:
- *   - a built-in id (e.g. "openbot", "shell"), or
- *   - an npm package name (e.g. "openbot-plugin-foo" or "@scope/foo"),
- *     in which case the folder layout is `plugins/<id>/dist/index.js`.
- */
-export async function resolvePlugin(id) {
-    if (cache.has(id))
-        return cache.get(id);
-    if (BUILT_IN[id]) {
-        cache.set(id, BUILT_IN[id]);
-        return BUILT_IN[id];
-    }
-    if (!pluginsDir) {
-        initPlugins();
-    }
-    if (!pluginsDir)
-        return null;
-    const distPath = path.join(pluginsDir, id, 'dist', 'index.js');
-    if (!fs.existsSync(distPath)) {
-        console.warn(`[plugins] Plugin "${id}" not found at ${distPath}.`);
-        return null;
-    }
-    try {
-        const module = await import(pathToFileURL(distPath).href);
-        const parsed = parsePluginModule(module);
-        if (!parsed) {
-            console.warn(`[plugins] Plugin "${id}" at ${distPath} has no recognizable export.`);
-            return null;
-        }
-        const plugin = { id, ...parsed, name: parsed.name || id };
-        cache.set(id, plugin);
-        if (!loadedPlugins.has(id)) {
-            console.log(`[plugins] Loaded community plugin "${id}" from ${distPath}`);
-            loadedPlugins.add(id);
-        }
-        return plugin;
-    }
-    catch (e) {
-        console.warn(`[plugins] Failed to load plugin "${id}" from ${distPath}:`, e);
-        return null;
-    }
-}
-/** Drop a single id from the in-memory cache (e.g. after fresh install). */
-export function invalidatePlugin(id) {
-    cache.delete(id);
-    loadedPlugins.delete(id);
-}
-/** List built-in plugins (for marketplace/registry views). */
-export function listBuiltInPlugins() {
-    return Object.values(BUILT_IN);
-}
-export function getPluginsDir() {
-    return pluginsDir;
-}

package/dist/services/agent-packages.js

@@ -1,103 +0,0 @@
-import fs from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-import { pathToFileURL } from 'node:url';
-import { DEFAULT_AGENT_PACKAGES_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath, } from '../app/config.js';
-import { parseAgentPackageModule } from '../registry/agents.js';
-const execAsync = promisify(exec);
-/**
- * Lifecycle for community-built agent packages distributed via npm.
- * The package format mirrors a normal npm package whose `dist/index.js`
- * exports `agentPackage` (or `default`) that satisfies the `AgentPackage`
- * interface.
- */
-export const agentPackageService = {
-    install: async ({ packageName, version }) => {
-        const config = loadConfig();
-        const baseDir = resolvePath(config.baseDir || DEFAULT_BASE_DIR);
-        const packagesDir = path.join(baseDir, DEFAULT_AGENT_PACKAGES_DIR);
-        await fs.mkdir(packagesDir, { recursive: true });
-        const target = version ? `${packageName}@${version}` : packageName;
-        const entries = await fs.readdir(packagesDir, { withFileTypes: true });
-        for (const entry of entries) {
-            if (entry.isDirectory() || entry.isSymbolicLink()) {
-                const pkgPath = path.join(packagesDir, entry.name, 'package.json');
-                if (existsSync(pkgPath)) {
-                    try {
-                        const pkgJson = JSON.parse(await fs.readFile(pkgPath, 'utf-8'));
-                        if (pkgJson.name === packageName && (!version || pkgJson.version === version)) {
-                            console.log(`[agent-packages] ${packageName}${version ? `@${version}` : ''} is already installed at ${entry.name}.`);
-                            return {
-                                name: pkgJson.name,
-                                id: entry.name,
-                                version: pkgJson.version,
-                            };
-                        }
-                    }
-                    catch {
-                        // ignore corrupted package.json
-                    }
-                }
-            }
-        }
-        console.log(`[agent-packages] Installing ${target} to ${packagesDir}...`);
-        try {
-            const tempDir = path.join(packagesDir, '.tmp_' + Date.now());
-            await fs.mkdir(tempDir, { recursive: true });
-            await execAsync(`npm install ${target} --no-save --prefix "${tempDir}"`);
-            const pkgNameOnly = packageName.includes('/') ? packageName.split('/').pop() : packageName;
-            const installedPath = path.join(tempDir, 'node_modules', packageName);
-            let finalId = pkgNameOnly;
-            try {
-                const distPath = path.join(installedPath, 'dist', 'index.js');
-                if (existsSync(distPath)) {
-                    const module = await import(pathToFileURL(distPath).href);
-                    const exported = parseAgentPackageModule(module);
-                    if (exported?.id)
-                        finalId = exported.id;
-                }
-            }
-            catch (e) {
-                console.warn(`[agent-packages] Could not read package metadata for ${packageName}; using folder name as id.`, e);
-            }
-            const finalPath = path.join(packagesDir, finalId);
-            await fs.rm(finalPath, { recursive: true, force: true });
-            await fs.rename(installedPath, finalPath);
-            await fs.rm(tempDir, { recursive: true, force: true });
-            console.log(`[agent-packages] Running npm install in ${finalPath}...`);
-            try {
-                await execAsync(`npm install`, { cwd: finalPath });
-                console.log(`[agent-packages] npm install completed in ${finalPath}`);
-            }
-            catch (e) {
-                console.warn(`[agent-packages] Failed to run npm install in ${finalPath}:`, e);
-            }
-            const pkgJson = JSON.parse(await fs.readFile(path.join(finalPath, 'package.json'), 'utf-8'));
-            return {
-                name: pkgJson.name,
-                id: finalId,
-                version: pkgJson.version,
-            };
-        }
-        catch (error) {
-            console.error(`[agent-packages] Failed to install ${packageName}:`, error);
-            throw new Error(`Failed to install agent package ${packageName}: ${error.message}`);
-        }
-    },
-    uninstall: async (id) => {
-        const config = loadConfig();
-        const baseDir = resolvePath(config.baseDir || DEFAULT_BASE_DIR);
-        const packagesDir = path.join(baseDir, DEFAULT_AGENT_PACKAGES_DIR);
-        const packagePath = path.join(packagesDir, id);
-        try {
-            await fs.rm(packagePath, { recursive: true, force: true });
-            console.log(`[agent-packages] Uninstalled agent package ${id}`);
-        }
-        catch (error) {
-            console.error(`[agent-packages] Failed to uninstall ${id}:`, error);
-            throw new Error(`Failed to uninstall agent package ${id}: ${error.message}`);
-        }
-    },
-};

package/dist/services/memory.js

@@ -1,152 +0,0 @@
-import fs from 'node:fs/promises';
-import path from 'node:path';
-import crypto from 'node:crypto';
-import { DEFAULT_BASE_DIR, loadConfig, resolvePath } from '../app/config.js';
-const DEFAULT_LIMIT = 50;
-const MAX_LIMIT = 500;
-const getMemoryDir = () => {
-    const config = loadConfig();
-    return path.join(resolvePath(config.baseDir || DEFAULT_BASE_DIR), 'memory');
-};
-const getLogPath = () => path.join(getMemoryDir(), 'log.jsonl');
-const ensureDir = async () => {
-    await fs.mkdir(getMemoryDir(), { recursive: true });
-};
-const readLog = async () => {
-    try {
-        const raw = await fs.readFile(getLogPath(), 'utf-8');
-        return raw
-            .split(/\r?\n/)
-            .map((line) => line.trim())
-            .filter(Boolean)
-            .map((line) => {
-            try {
-                return JSON.parse(line);
-            }
-            catch {
-                return null;
-            }
-        })
-            .filter((e) => !!e);
-    }
-    catch (e) {
-        if (e?.code === 'ENOENT')
-            return [];
-        throw e;
-    }
-};
-const replay = (entries) => {
-    const out = new Map();
-    for (const entry of entries) {
-        if (entry.op === 'add') {
-            out.set(entry.record.id, entry.record);
-        }
-        else if (entry.op === 'delete') {
-            out.delete(entry.id);
-        }
-        else if (entry.op === 'update') {
-            const existing = out.get(entry.id);
-            if (!existing)
-                continue;
-            out.set(entry.id, {
-                ...existing,
-                ...entry.patch,
-                id: existing.id,
-                updatedAt: entry.at,
-            });
-        }
-    }
-    return out;
-};
-const appendEntry = async (entry) => {
-    await ensureDir();
-    await fs.appendFile(getLogPath(), `${JSON.stringify(entry)}\n`, 'utf-8');
-};
-const matchesQuery = (record, query, tag) => {
-    if (tag) {
-        if (!record.tags || !record.tags.includes(tag))
-            return false;
-    }
-    if (query) {
-        const q = query.toLowerCase();
-        if (!record.content.toLowerCase().includes(q))
-            return false;
-    }
-    return true;
-};
-export const memoryService = {
-    appendMemory: async (args) => {
-        const now = new Date().toISOString();
-        const record = {
-            id: crypto.randomUUID(),
-            scope: args.scope,
-            content: args.content,
-            tags: args.tags?.length ? args.tags : undefined,
-            createdAt: now,
-            updatedAt: now,
-        };
-        await appendEntry({ op: 'add', record });
-        return record;
-    },
-    updateMemory: async (args) => {
-        const entries = await readLog();
-        const map = replay(entries);
-        if (!map.has(args.id))
-            return false;
-        const at = new Date().toISOString();
-        const patch = {};
-        if (args.content !== undefined)
-            patch.content = args.content;
-        if (args.tags !== undefined)
-            patch.tags = args.tags.length ? args.tags : undefined;
-        if (Object.keys(patch).length === 0)
-            return true;
-        await appendEntry({ op: 'update', id: args.id, patch, at });
-        return true;
-    },
-    deleteMemory: async (args) => {
-        const entries = await readLog();
-        const map = replay(entries);
-        if (!map.has(args.id))
-            return false;
-        await appendEntry({ op: 'delete', id: args.id, at: new Date().toISOString() });
-        return true;
-    },
-    listMemories: async (args = {}) => {
-        const entries = await readLog();
-        const map = replay(entries);
-        const limit = Math.min(Math.max(args.limit ?? DEFAULT_LIMIT, 1), MAX_LIMIT);
-        const scopeSet = (() => {
-            if (args.scope)
-                return new Set([args.scope]);
-            if (args.scopes && args.scopes.length > 0)
-                return new Set(args.scopes);
-            return null;
-        })();
-        const filtered = [];
-        for (const record of map.values()) {
-            if (scopeSet && !scopeSet.has(record.scope))
-                continue;
-            if (!matchesQuery(record, args.query, args.tag))
-                continue;
-            filtered.push(record);
-        }
-        filtered.sort((a, b) => (a.updatedAt < b.updatedAt ? 1 : -1));
-        return filtered.slice(0, limit);
-    },
-    /**
-     * Compact the log into a single `add` per surviving record. Cheap to call
-     * occasionally; not required for correctness.
-     */
-    compact: async () => {
-        const entries = await readLog();
-        const map = replay(entries);
-        const surviving = Array.from(map.values());
-        await ensureDir();
-        const tmp = `${getLogPath()}.tmp`;
-        const body = surviving.map((record) => JSON.stringify({ op: 'add', record })).join('\n');
-        await fs.writeFile(tmp, body ? `${body}\n` : '', 'utf-8');
-        await fs.rename(tmp, getLogPath());
-        return surviving.length;
-    },
-};

package/dist/services/plugins.js

@@ -1,98 +0,0 @@
-import fs from 'node:fs/promises';
-import { existsSync } from 'node:fs';
-import path from 'node:path';
-import { exec } from 'node:child_process';
-import { promisify } from 'node:util';
-import { DEFAULT_PLUGINS_DIR, DEFAULT_BASE_DIR, loadConfig, resolvePath, } from '../app/config.js';
-import { invalidatePlugin } from '../registry/plugins.js';
-const execAsync = promisify(exec);
-const getPluginsDir = () => {
-    const config = loadConfig();
-    const baseDir = resolvePath(config.baseDir || DEFAULT_BASE_DIR);
-    return path.join(baseDir, DEFAULT_PLUGINS_DIR);
-};
-/**
- * Lifecycle for community-built plugins distributed via npm.
- * Each plugin is installed to `<plugins>/<npm-name>/` and is identified
- * everywhere (AGENT.md `plugins[].id`, registry, runtime resolution) by its
- * npm name. Scoped packages (`@scope/foo`) live under `<plugins>/@scope/foo/`.
- */
-export const pluginService = {
-    isInstalled: async (packageName) => {
-        const finalPath = path.join(getPluginsDir(), packageName);
-        return existsSync(path.join(finalPath, 'dist', 'index.js'));
-    },
-    install: async ({ packageName, version }) => {
-        const pluginsDir = getPluginsDir();
-        await fs.mkdir(pluginsDir, { recursive: true });
-        const finalPath = path.join(pluginsDir, packageName);
-        if (existsSync(path.join(finalPath, 'package.json'))) {
-            try {
-                const pkgJson = JSON.parse(await fs.readFile(path.join(finalPath, 'package.json'), 'utf-8'));
-                if (!version || pkgJson.version === version) {
-                    console.log(`[plugins] ${packageName}${version ? `@${version}` : ''} is already installed.`);
-                    return { name: pkgJson.name, version: pkgJson.version };
-                }
-            }
-            catch {
-                // corrupted; reinstall below
-            }
-        }
-        const target = version ? `${packageName}@${version}` : packageName;
-        console.log(`[plugins] Installing ${target} to ${pluginsDir}...`);
-        const tempDir = path.join(pluginsDir, '.tmp_' + Date.now());
-        try {
-            await fs.mkdir(tempDir, { recursive: true });
-            await execAsync(`npm install ${target} --no-save --prefix "${tempDir}"`);
-            const installedPath = path.join(tempDir, 'node_modules', packageName);
-            if (!existsSync(installedPath)) {
-                throw new Error(`npm did not produce ${installedPath}`);
-            }
-            await fs.mkdir(path.dirname(finalPath), { recursive: true });
-            await fs.rm(finalPath, { recursive: true, force: true });
-            await fs.rename(installedPath, finalPath);
-            console.log(`[plugins] Running npm install in ${finalPath}...`);
-            try {
-                await execAsync(`npm install`, { cwd: finalPath });
-                console.log(`[plugins] npm install completed in ${finalPath}`);
-            }
-            catch (e) {
-                console.warn(`[plugins] Failed to run npm install in ${finalPath}:`, e);
-            }
-            const pkgJson = JSON.parse(await fs.readFile(path.join(finalPath, 'package.json'), 'utf-8'));
-            invalidatePlugin(packageName);
-            return { name: pkgJson.name, version: pkgJson.version };
-        }
-        catch (error) {
-            console.error(`[plugins] Failed to install ${packageName}:`, error);
-            throw new Error(`Failed to install plugin ${packageName}: ${error.message}`);
-        }
-        finally {
-            await fs.rm(tempDir, { recursive: true, force: true }).catch(() => { });
-        }
-    },
-    uninstall: async (packageName) => {
-        const pluginsDir = getPluginsDir();
-        const pluginPath = path.join(pluginsDir, packageName);
-        try {
-            await fs.rm(pluginPath, { recursive: true, force: true });
-            invalidatePlugin(packageName);
-            console.log(`[plugins] Uninstalled plugin ${packageName}`);
-            if (packageName.startsWith('@')) {
-                const scopeDir = path.dirname(pluginPath);
-                try {
-                    const remaining = await fs.readdir(scopeDir);
-                    if (remaining.length === 0)
-                        await fs.rmdir(scopeDir);
-                }
-                catch {
-                    // ignore
-                }
-            }
-        }
-        catch (error) {
-            console.error(`[plugins] Failed to uninstall ${packageName}:`, error);
-            throw new Error(`Failed to uninstall plugin ${packageName}: ${error.message}`);
-        }
-    },
-};