openbot 0.2.3 → 0.2.6

package/dist/core/router.js

@@ -0,0 +1,40 @@
+export async function* runOpenBot(event, context, managerRuntime, agentRuntimes) {
+    const { state } = context;
+    // Initialize state
+    if (!state.messages)
+        state.messages = [];
+    if (!state.agentStates)
+        state.agentStates = {};
+    // 1. Direct agent routing (e.g. "@os list files")
+    if (event.type === "agent:input") {
+        const content = event.data.content;
+        if (content?.startsWith("@")) {
+            const match = content.match(/^@([a-zA-Z0-9_-]+)\s*(.*)$/);
+            if (match) {
+                const [, agentName, remaining] = match;
+                const runtime = agentRuntimes.get(agentName);
+                if (runtime) {
+                    if (!state.agentStates[agentName])
+                        state.agentStates[agentName] = {};
+                    const agentEvent = {
+                        ...event,
+                        data: {
+                            content: remaining || "Hello",
+                            attachments: event.data.attachments,
+                        },
+                    };
+                    yield* runtime.run(agentEvent, {
+                        runId: context.runId,
+                        state: state.agentStates[agentName],
+                    });
+                    return;
+                }
+            }
+        }
+    }
+    // 2. Default routing: translate user event to manager input
+    yield* managerRuntime.run({ ...event, type: "agent:input" }, {
+        runId: context.runId,
+        state: state,
+    });
+}

package/dist/installers.js

@@ -0,0 +1,156 @@
+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 { 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 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 {
+        const url = `https://github.com/${repo}.git`;
+        run("git", ["ls-remote", url], { 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 parseSource(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 async function installExtension(type, source, options = {}) {
+    const quiet = !!options.quiet;
+    const baseDir = getBaseDir();
+    const targetRoot = path.join(baseDir, type === "agent" ? "agents" : "plugins");
+    await fs.mkdir(targetRoot, { recursive: true });
+    // 1. Determine the folder name (the "id") - ALWAYS based on source or explicit id
+    let id = options.id;
+    if (!id) {
+        if (source.type === "github") {
+            id = path.basename(source.value); // e.g. "agent-browser"
+        }
+        else if (source.type === "npm") {
+            id = source.value.split("/").pop(); // e.g. "@melony/plugin-test" -> "plugin-test"
+        }
+        else {
+            id = path.basename(source.value);
+        }
+    }
+    const targetDir = path.join(targetRoot, id);
+    const tempDir = path.join(tmpdir(), `openbot-install-${Date.now()}-${id}`);
+    try {
+        log(`📦 Installing ${type} "${id}" from ${source.type}...`, quiet);
+        if (source.type === "github") {
+            const url = `https://github.com/${source.value}.git`;
+            run("git", ["clone", "--depth", "1", url, tempDir], { quiet });
+        }
+        else if (source.type === "npm") {
+            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 {
+            await fs.mkdir(tempDir, { recursive: true });
+            await fs.cp(source.value, tempDir, { recursive: true });
+        }
+        if (await directoryExists(targetDir)) {
+            log(`⚠️  Removing existing folder: ${targetDir}`, quiet);
+            await fs.rm(targetDir, { recursive: true, force: true });
+        }
+        await fs.rename(tempDir, targetDir);
+        log(`✅ Installed to: ${targetDir}`, quiet);
+        // Prepare dependencies and build
+        await ensurePluginReady(targetDir);
+        // If it's an agent, check for missing plugins
+        if (type === "agent") {
+            await installMissingPluginsFromAgent(targetDir, { quiet });
+        }
+        log(`🎉 Successfully installed ${type}: ${id}`, quiet);
+        return id;
+    }
+    catch (error) {
+        await fs.rm(tempDir, { recursive: true, force: true }).catch(() => undefined);
+        throw error;
+    }
+}
+// Backward compatibility aliases
+export const installPluginFromSource = (source, opts) => installExtension("plugin", source, opts);
+export const installAgentFromSource = (source, opts) => installExtension("agent", source, opts);
+export const parsePluginInstallSource = parseSource;
+export const parseAgentInstallSource = parseSource;
+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;
+        // Check if it already exists as a folder in plugins/
+        const pluginPath = path.join(baseDir, "plugins", pluginName);
+        const prefixedPluginPath = path.join(baseDir, "plugins", `plugin-${pluginName}`);
+        if (await (directoryExists(pluginPath)) || await (directoryExists(prefixedPluginPath))) {
+            continue;
+        }
+        log(`🔍 Agent needs plugin "${pluginName}". Searching...`, quiet);
+        const ghRepo = `meetopenbot/plugin-${pluginName}`;
+        if (checkGitHubRepo(ghRepo)) {
+            await installExtension("plugin", { type: "github", value: ghRepo }, { quiet });
+            continue;
+        }
+        const npmPkg = `@melony/plugin-${pluginName}`;
+        if (checkNpmPackage(npmPkg)) {
+            await installExtension("plugin", { type: "npm", value: npmPkg }, { quiet });
+            continue;
+        }
+        log(`⚠️  Could not find plugin "${pluginName}" for this agent.`, 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 }, { id: agent.id });
+    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, { id: plugin.id });
+    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,
-    });
 }