openbot 0.2.14 → 0.3.1

package/dist/services/memory.js

@@ -0,0 +1,152 @@
+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

@@ -0,0 +1,98 @@
+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}`);
+        }
+    },
+};