openbot 0.2.2 → 0.2.5

package/dist/installers.js

@@ -0,0 +1,170 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { execFileSync } from "node:child_process";
+import { tmpdir } from "node:os";
+import { resolvePath, DEFAULT_BASE_DIR, loadConfig } from "./config.js";
+import { getPluginMetadata, readAgentConfig, ensurePluginReady } from "./registry/plugin-loader.js";
+const BUILT_IN_PLUGIN_NAMES = new Set(["shell", "file-system", "approval"]);
+function run(command, args, options) {
+    execFileSync(command, args, {
+        cwd: options?.cwd,
+        stdio: options?.quiet ? "ignore" : "inherit",
+    });
+}
+function log(message, quiet) {
+    if (!quiet)
+        console.log(message);
+}
+function githubRepoToCloneUrl(repo) {
+    return `https://github.com/${repo}.git`;
+}
+function getBaseDir() {
+    const cfg = loadConfig();
+    const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
+    return resolvePath(baseDir);
+}
+async function directoryExists(targetPath) {
+    return fs.access(targetPath).then(() => true).catch(() => false);
+}
+export function checkGitHubRepo(repo) {
+    try {
+        run("git", ["ls-remote", githubRepoToCloneUrl(repo)], { quiet: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function checkNpmPackage(pkg) {
+    try {
+        run("npm", ["show", pkg, "version"], { quiet: true });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function parsePluginInstallSource(source) {
+    const normalized = source.trim();
+    const isGithub = (normalized.includes("/") || normalized.startsWith("github:"))
+        && !normalized.startsWith("/")
+        && !normalized.startsWith(".");
+    const isNpm = normalized.startsWith("@") || normalized.startsWith("npm:");
+    if (isGithub) {
+        return {
+            type: "github",
+            value: normalized.startsWith("github:") ? normalized.slice(7) : normalized,
+        };
+    }
+    if (isNpm) {
+        return {
+            type: "npm",
+            value: normalized.startsWith("npm:") ? normalized.slice(4) : normalized,
+        };
+    }
+    return { type: "local", value: path.resolve(normalized) };
+}
+export function parseAgentInstallSource(source) {
+    const normalized = source.trim();
+    if (normalized.startsWith("github:")) {
+        return { type: "github", value: normalized.slice(7) };
+    }
+    return { type: "github", value: normalized };
+}
+export async function installPluginFromSource(source, options = {}) {
+    const quiet = !!options.quiet;
+    const tempDir = path.join(tmpdir(), `openbot-plugin-install-${Date.now()}`);
+    const baseDir = getBaseDir();
+    const pluginRoot = path.join(baseDir, "plugins");
+    await fs.mkdir(pluginRoot, { recursive: true });
+    try {
+        if (source.type === "github") {
+            log(`📦 Installing plugin from: ${githubRepoToCloneUrl(source.value)}`, quiet);
+            run("git", ["clone", "--depth", "1", githubRepoToCloneUrl(source.value), tempDir], { quiet });
+        }
+        else if (source.type === "npm") {
+            log(`📦 Installing plugin from: ${source.value}`, quiet);
+            await fs.mkdir(tempDir, { recursive: true });
+            run("npm", ["install", source.value, "--prefix", tempDir], { quiet });
+            const pkgFolder = path.join(tempDir, "node_modules", source.value);
+            const moveTemp = path.join(tmpdir(), `openbot-npm-move-${Date.now()}`);
+            await fs.rename(pkgFolder, moveTemp);
+            await fs.rm(tempDir, { recursive: true, force: true });
+            await fs.rename(moveTemp, tempDir);
+        }
+        else {
+            log(`📦 Installing plugin from: ${source.value}`, quiet);
+            await fs.mkdir(tempDir, { recursive: true });
+            await fs.cp(source.value, tempDir, { recursive: true });
+        }
+        const { name } = await getPluginMetadata(tempDir);
+        const targetDir = path.join(pluginRoot, name);
+        if (await directoryExists(targetDir)) {
+            log(`⚠️  Plugin "${name}" already exists. Overwriting...`, quiet);
+            await fs.rm(targetDir, { recursive: true, force: true });
+        }
+        await fs.rename(tempDir, targetDir);
+        log(`✅ Moved to: ${targetDir}`, quiet);
+        log(`⚙️  Preparing plugin "${name}"...`, quiet);
+        await ensurePluginReady(targetDir);
+        log(`\n🎉 Successfully installed plugin: ${name}`, quiet);
+        return name;
+    }
+    catch (error) {
+        await fs.rm(tempDir, { recursive: true, force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+export async function installAgentFromSource(source, options = {}) {
+    const quiet = !!options.quiet;
+    const tempDir = path.join(tmpdir(), `openbot-agent-install-${Date.now()}`);
+    const baseDir = getBaseDir();
+    const agentRoot = path.join(baseDir, "agents");
+    await fs.mkdir(agentRoot, { recursive: true });
+    try {
+        log(`🤖 Installing agent from: ${githubRepoToCloneUrl(source.value)}`, quiet);
+        run("git", ["clone", "--depth", "1", githubRepoToCloneUrl(source.value), tempDir], { quiet });
+        const config = await readAgentConfig(tempDir);
+        const name = config.name || path.basename(source.value).replace(/^agent-/, "");
+        const targetDir = path.join(agentRoot, name);
+        if (await directoryExists(targetDir)) {
+            log(`⚠️  Agent "${name}" already exists. Overwriting...`, quiet);
+            await fs.rm(targetDir, { recursive: true, force: true });
+        }
+        await fs.rename(tempDir, targetDir);
+        log(`✅ Moved to: ${targetDir}`, quiet);
+        await installMissingPluginsFromAgent(targetDir, { quiet });
+        log(`\n🎉 Successfully installed agent: ${name}`, quiet);
+        return name;
+    }
+    catch (error) {
+        await fs.rm(tempDir, { recursive: true, force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+export async function installMissingPluginsFromAgent(agentFolder, options = {}) {
+    const quiet = !!options.quiet;
+    const config = await readAgentConfig(agentFolder);
+    const baseDir = getBaseDir();
+    for (const pluginItem of config.plugins || []) {
+        const pluginName = typeof pluginItem === "string" ? pluginItem : pluginItem.name;
+        if (!pluginName || BUILT_IN_PLUGIN_NAMES.has(pluginName))
+            continue;
+        const pluginPath = path.join(baseDir, "plugins", pluginName);
+        const existsLocally = await directoryExists(pluginPath);
+        if (existsLocally)
+            continue;
+        log(`🔍 Agent needs plugin "${pluginName}". Searching...`, quiet);
+        const ghRepo = `meetopenbot/plugin-${pluginName}`;
+        if (checkGitHubRepo(ghRepo)) {
+            await installPluginFromSource({ type: "github", value: ghRepo }, { quiet });
+            continue;
+        }
+        const npmPkg = `@melony/plugin-${pluginName}`;
+        if (checkNpmPackage(npmPkg)) {
+            await installPluginFromSource({ type: "npm", value: npmPkg }, { quiet });
+            continue;
+        }
+        log(`⚠️  Could not find plugin "${pluginName}" for this agent. You may need to install it manually.`, quiet);
+    }
+}

package/dist/marketplace.js

@@ -0,0 +1,80 @@
+import { installAgentFromSource, installPluginFromSource } from "./installers.js";
+const DEFAULT_MARKETPLACE_REGISTRY_URL = "https://raw.githubusercontent.com/meetopenbot/openbot-registry/main/registry.json";
+const CACHE_TTL_MS = 5 * 60 * 1000;
+let cachedRegistry = null;
+let cacheExpiresAt = 0;
+function normalizeSource(source) {
+    if (!source || typeof source !== "object") {
+        throw new Error("invalid source");
+    }
+    const value = source;
+    if ((value.type !== "github" && value.type !== "npm") || typeof value.value !== "string" || !value.value.trim()) {
+        throw new Error("invalid source");
+    }
+    return { type: value.type, value: value.value.trim() };
+}
+function normalizeItem(item) {
+    if (!item || typeof item !== "object")
+        throw new Error("invalid item");
+    const value = item;
+    if (typeof value.id !== "string" || !value.id.trim())
+        throw new Error("invalid item id");
+    if (typeof value.name !== "string" || !value.name.trim())
+        throw new Error("invalid item name");
+    if (typeof value.description !== "string")
+        throw new Error("invalid item description");
+    const tags = Array.isArray(value.tags) ? value.tags.filter((tag) => typeof tag === "string") : undefined;
+    return {
+        id: value.id.trim(),
+        name: value.name.trim(),
+        description: value.description,
+        source: normalizeSource(value.source),
+        tags,
+        image: typeof value.image === "string" ? value.image.trim() : undefined,
+    };
+}
+function normalizeRegistry(value) {
+    if (!value || typeof value !== "object")
+        throw new Error("invalid registry");
+    const raw = value;
+    if (typeof raw.version !== "number")
+        throw new Error("invalid version");
+    const agents = Array.isArray(raw.agents) ? raw.agents.map(normalizeItem) : [];
+    const plugins = Array.isArray(raw.plugins) ? raw.plugins.map(normalizeItem) : [];
+    return { version: raw.version, agents, plugins };
+}
+export async function getMarketplaceRegistry(forceRefresh = false) {
+    const now = Date.now();
+    if (!forceRefresh && cachedRegistry && now < cacheExpiresAt) {
+        return cachedRegistry;
+    }
+    const registryUrl = process.env.OPENBOT_MARKETPLACE_REGISTRY_URL || DEFAULT_MARKETPLACE_REGISTRY_URL;
+    const response = await fetch(registryUrl);
+    if (!response.ok) {
+        throw new Error(`Failed to fetch marketplace registry (${response.status})`);
+    }
+    const json = await response.json();
+    const normalized = normalizeRegistry(json);
+    cachedRegistry = normalized;
+    cacheExpiresAt = now + CACHE_TTL_MS;
+    return normalized;
+}
+export async function installMarketplaceAgent(agentId) {
+    const registry = await getMarketplaceRegistry(true);
+    const agent = registry.agents.find((entry) => entry.id === agentId);
+    if (!agent)
+        throw new Error(`Agent "${agentId}" was not found in marketplace`);
+    if (agent.source.type !== "github") {
+        throw new Error(`Marketplace agent "${agentId}" has unsupported source type "${agent.source.type}"`);
+    }
+    const installedName = await installAgentFromSource({ type: "github", value: agent.source.value });
+    return { installedName, agent };
+}
+export async function installMarketplacePlugin(pluginId) {
+    const registry = await getMarketplaceRegistry(true);
+    const plugin = registry.plugins.find((entry) => entry.id === pluginId);
+    if (!plugin)
+        throw new Error(`Plugin "${pluginId}" was not found in marketplace`);
+    const installedName = await installPluginFromSource(plugin.source);
+    return { installedName, plugin };
+}

package/dist/open-bot.js

@@ -1,26 +1,13 @@
-import { osAgent } from "./agents/os-agent.js";
-import { topicAgent } from "./agents/topic-agent.js";
-import { agentCreatorAgent } from "./agents/agent-creator.js";
-import { brainPlugin, brainToolDefinitions, createBrainPromptBuilder } from "./plugins/brain/index.js";
-import { llmPlugin } from "./plugins/llm/index.js";
+import { melony } from "melony";
 import { loadConfig, resolvePath, DEFAULT_BASE_DIR } from "./config.js";
 import { createModel, parseModelString } from "./models.js";
 import { DEFAULT_MODEL_ID } from "./model-defaults.js";
-import path from "node:path";
-import { z } from "zod";
-import { shellPlugin, shellToolDefinitions } from "./plugins/shell/index.js";
-import { fileSystemPlugin, fileSystemToolDefinitions } from "./plugins/file-system/index.js";
-import { approvalPlugin } from "./plugins/approval/index.js";
-import { PluginRegistry, AgentRegistry, discoverYamlAgents, discoverTsAgents, loadPluginsFromDir } from "./registry/index.js";
-import { Orchestrator } from "./orchestrator.js";
+import { setupPluginRegistry } from "./core/plugins.js";
+import { createManagerPlugin } from "./core/manager.js";
+import { setupDelegation } from "./core/delegation.js";
+import { runOpenBot } from "./core/router.js";
 /**
- * Create the OpenBot orchestrator.
- *
- * Architecture:
- *  1. Each agent gets its own isolated melony runtime (no shared handlers or state).
- *  2. The manager has its own runtime with brain tools and a delegateTask tool.
- *  3. The Orchestrator routes events between manager and agent runtimes.
- *  4. Plugins are only instantiated within the runtime that needs them — no duplication.
+ * Create the OpenBot runtime.
  */
 export async function createOpenBot(options) {
     const config = loadConfig();
@@ -30,145 +17,35 @@ export async function createOpenBot(options) {
     const { provider, modelId } = parseModelString(configuredModel);
     const resolvedModelId = `${provider}/${modelId}`;
     const model = createModel(options);
-    // ─── Plugin Registry ─────────────────────────────────────────────
-    const pluginRegistry = new PluginRegistry();
-    pluginRegistry.register({
-        name: "shell",
-        description: "Execute shell commands",
-        toolDefinitions: shellToolDefinitions,
-        factory: () => shellPlugin({ cwd: process.cwd() }),
-    });
-    pluginRegistry.register({
-        name: "file-system",
-        description: "Read, write, list, and delete files",
-        toolDefinitions: fileSystemToolDefinitions,
-        factory: () => fileSystemPlugin({ baseDir: "/" }),
-    });
-    pluginRegistry.register({
-        name: "approval",
-        description: "Require user approval for specific actions",
-        toolDefinitions: {},
-        factory: (options) => approvalPlugin(options),
-    });
-    // ─── Shared Plugins ──────────────────────────────────────────────
-    const sharedPlugins = await loadPluginsFromDir(path.join(resolvedBaseDir, "plugins"));
-    for (const p of sharedPlugins) {
-        pluginRegistry.register(p);
-        console.log(`[plugins] Loaded shared plugin: ${p.name}`);
+    // 1. Setup unified registry (built-in tools + agents + community plugins)
+    const registry = await setupPluginRegistry(resolvedBaseDir, model, options);
+    // 2. Initialize agent runtimes
+    const agentRuntimes = new Map();
+    for (const agent of registry.getAgents()) {
+        const builder = melony();
+        builder.use(agent.plugin);
+        agentRuntimes.set(agent.name, builder.build());
     }
-    // ─── Agent Registry ──────────────────────────────────────────────
-    const agentRegistry = new AgentRegistry();
-    agentRegistry.register({
-        name: "os",
-        description: "Handles shell commands and file system operations",
-        capabilities: {
-            ...Object.fromEntries(Object.entries(shellToolDefinitions).map(([k, v]) => [k, v.description])),
-            ...Object.fromEntries(Object.entries(fileSystemToolDefinitions).map(([k, v]) => [k, v.description])),
-        },
-        plugin: osAgent({ model: model }),
-    });
-    agentRegistry.register({
-        name: "agent-creator",
-        description: "Helps the user create and configure new custom OpenBot agents via natural language.",
-        capabilities: {
-            ...Object.fromEntries(Object.entries(fileSystemToolDefinitions).map(([k, v]) => [k, v.description])),
-        },
-        plugin: agentCreatorAgent({ model: model }),
-    });
-    // Discover community / user agents from ~/.openbot/agents/
-    const agentsDir = path.join(resolvedBaseDir, "agents");
-    const [yamlAgents, tsAgents] = await Promise.all([
-        discoverYamlAgents(agentsDir, pluginRegistry, model, options),
-        discoverTsAgents(agentsDir, model, options),
-    ]);
-    for (const agent of [...yamlAgents, ...tsAgents]) {
-        agentRegistry.register(agent);
+    // 3. Initialize manager runtime
+    const managerBuilder = melony();
+    managerBuilder.use(createManagerPlugin(model, resolvedModelId, resolvedBaseDir, registry));
+    // 4. Setup delegation
+    setupDelegation(managerBuilder, agentRuntimes);
+    const managerRuntime = managerBuilder.build();
+    // 5. Trigger initialization for all runtimes
+    const initPromises = [];
+    const exhaust = async (runtime) => {
+        const iterator = runtime.run({ type: "init" }, { runId: "init", state: {} });
+        for await (const _ of iterator) { /* side-effects only */ }
+    };
+    for (const agentRuntime of agentRuntimes.values()) {
+        initPromises.push(exhaust(agentRuntime));
     }
-    // ─── Build Orchestrator ──────────────────────────────────────────
-    const allAgents = agentRegistry.getAll();
-    const agentNames = agentRegistry.getNames();
-    const buildBrainPrompt = createBrainPromptBuilder(baseDir);
-    const agentDescriptions = allAgents
-        .map((a) => {
-        const tools = a.capabilities
-            ? Object.entries(a.capabilities)
-                .map(([name, desc]) => `    - ${name}: ${desc}`)
-                .join("\n")
-            : "";
-        return `<agent name="${a.name}">
-  <description>${a.description}</description>
-${tools ? `  <capabilities>\n${tools}\n  </capabilities>` : ""}
-</agent>`;
-    })
-        .join("\n\n");
-    // The manager plugin composes brain, topic, and the manager LLM
-    const managerPlugin = (builder) => {
-        builder
-            .use(brainPlugin({
-            baseDir: resolvedBaseDir,
-            allowSoulModification: false,
-        }))
-            .use(topicAgent({ model: model }))
-            .use(llmPlugin({
-            model: model,
-            modelId: resolvedModelId,
-            usageScope: "manager",
-            system: async (context) => {
-                const brainPrompt = await buildBrainPrompt(context);
-                return `${brainPrompt}
-
-<manager_core>
-<role>
-Your role is to be the central orchestrator of this system. Your primary goal is to solve user requests by managing your persistent memory and delegating tasks to expert sub-agents.
-</role>
-
-<operating_principles>
-1. **Delegate by Default**: If a task requires specialized expertise (shell, files, browser, etc.), you **must** delegate to an expert agent via \`delegateTask\`.
-2. **Context-Rich Delegation**: When calling \`delegateTask\`, provide a thorough, context-rich task description so the sub-agent can work independently. If the user included attachments, pass them through \`attachments\`.
-3. **Concise Reporting**: After a sub-agent finishes, provide a high-level, concise summary to the user. Do not repeat technical details unless requested.
-4. **Memory Management**: Use your brain tools (\`remember\`, \`recall\`, \`journal\`, etc.) to maintain continuity and preferences across sessions.
-</operating_principles>
-</manager_core>
-
-<specialized_agents>
-${agentDescriptions}
-</specialized_agents>
-
-<final_guidance>
-Always remain professional and efficient. You manage the big picture; let the agents do the work.
-</final_guidance>`;
-            },
-            promptInputType: "manager:input",
-            actionResultInputType: "manager:result",
-            completionEventType: "manager:completion",
-            toolDefinitions: {
-                ...brainToolDefinitions,
-                delegateTask: {
-                    description: `Delegate a specialized task to another agent. Use this whenever a task matches the capabilities of one of the available agents.`,
-                    inputSchema: z.object({
-                        agent: z.enum(agentNames).describe("The specialized agent to use"),
-                        task: z.string().describe("The detailed task description for the agent"),
-                        attachments: z.array(z.object({
-                            id: z.string(),
-                            name: z.string(),
-                            mimeType: z.string(),
-                            size: z.number(),
-                            url: z.string(),
-                        })).optional().describe("Image/file attachments from the user message, if present."),
-                    }),
-                },
-            },
-        }));
+    initPromises.push(exhaust(managerRuntime));
+    await Promise.all(initPromises);
+    // 6. Return the runtime
+    return {
+        registry,
+        run: (event, context) => runOpenBot(event, context, managerRuntime, agentRuntimes),
     };
-    // Collect agents for the orchestrator (excludes topic since it's a manager plugin now)
-    const orchestratorAgents = allAgents.map((a) => ({
-        name: a.name,
-        description: a.description,
-        plugin: a.plugin,
-        capabilities: a.capabilities,
-    }));
-    return new Orchestrator({
-        managerPlugin,
-        agents: orchestratorAgents,
-    });
 }