openbot 0.2.3 → 0.2.6

package/dist/cli.js

@@ -3,171 +3,58 @@ import { Command } from "commander";
 import * as readline from "node:readline/promises";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
-import { execSync } from "node:child_process";
-import { tmpdir } from "node:os";
+import { spawn } from "node:child_process";
 import { saveConfig, resolvePath, DEFAULT_BASE_DIR } from "./config.js";
 import { startServer } from "./server.js";
-import { ensurePluginReady, getPluginMetadata } from "./registry/plugin-loader.js";
-import { readAgentConfig } from "./registry/yaml-agent-loader.js";
+import { getPluginMetadata } from "./registry/plugin-loader.js";
+import { checkGitHubRepo, checkNpmPackage, parsePluginInstallSource, parseAgentInstallSource, installPluginFromSource, installAgentFromSource, } from "./installers.js";
 const program = new Command();
+const REQUIRED_NODE_VERSION = "20.12.0";
+function checkNodeVersion() {
+    const [major, minor, patch] = process.versions.node.split(".").map(Number);
+    const [reqMajor, reqMinor, reqPatch] = REQUIRED_NODE_VERSION.split(".").map(Number);
+    const isOld = major < reqMajor ||
+        (major === reqMajor && minor < reqMinor) ||
+        (major === reqMajor && minor === reqMinor && patch < reqPatch);
+    if (isOld) {
+        console.warn(`\n⚠️  WARNING: You are using Node.js ${process.version}.`);
+        console.warn(`   OpenBot works best with Node.js >=${REQUIRED_NODE_VERSION}.`);
+        console.warn(`   You may encounter "ERR_REQUIRE_ESM" or other compatibility issues on older versions.\n`);
+    }
+}
+checkNodeVersion();
 program
     .name("openbot")
     .description("OpenBot CLI - Secure and easy configuration")
-    .version("0.2.3");
-/**
- * Check if a GitHub repository exists.
- */
-function checkGitHubRepo(repo) {
-    try {
-        execSync(`git ls-remote https://github.com/${repo}.git`, { stdio: "ignore" });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Check if an NPM package exists.
- */
-function checkNpmPackage(pkg) {
-    try {
-        execSync(`npm show ${pkg} version`, { stdio: "ignore" });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Install a plugin from a source (GitHub, local, or NPM).
- */
-async function installPlugin(source, quiet = false) {
-    const isGitHub = (source.includes("/") || source.startsWith("github:")) && !source.startsWith("/") && !source.startsWith(".");
-    const isNpm = source.startsWith("@") || source.startsWith("npm:");
-    const repoUrl = isGitHub
-        ? (source.startsWith("github:") ? `https://github.com/${source.slice(7)}.git` : `https://github.com/${source}.git`)
-        : source;
-    const tempDir = path.join(tmpdir(), `openbot-plugin-install-${Date.now()}`);
+    .version("0.2.6");
+async function installPlugin(source, id, quiet = false) {
     try {
-        if (!quiet)
-            console.log(`📦 Installing plugin from: ${isNpm ? source : repoUrl}`);
-        // 1. Fetch to temp directory
-        if (isGitHub) {
-            execSync(`git clone --depth 1 ${repoUrl} ${tempDir}`, { stdio: quiet ? "ignore" : "inherit" });
-        }
-        else if (isNpm) {
-            const pkgName = source.startsWith("npm:") ? source.slice(4) : source;
-            await fs.mkdir(tempDir, { recursive: true });
-            execSync(`npm install ${pkgName} --prefix ${tempDir}`, { stdio: quiet ? "ignore" : "inherit" });
-            // Move from node_modules to tempDir root for consistency
-            const pkgFolder = path.join(tempDir, "node_modules", pkgName);
-            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 {
-            const absoluteSource = path.resolve(source);
-            await fs.mkdir(tempDir, { recursive: true });
-            execSync(`cp -R ${absoluteSource}/. ${tempDir}`, { stdio: quiet ? "ignore" : "inherit" });
-        }
-        // 2. Identify name from metadata
-        const { name } = await getPluginMetadata(tempDir);
-        const baseDir = resolvePath(DEFAULT_BASE_DIR);
-        const targetDir = path.join(baseDir, "plugins", name);
-        // 3. Move to target directory
-        await fs.mkdir(path.dirname(targetDir), { recursive: true });
-        if (await fs.access(targetDir).then(() => true).catch(() => false)) {
-            if (!quiet)
-                console.log(`⚠️  Plugin "${name}" already exists. Overwriting...`);
-            await fs.rm(targetDir, { recursive: true, force: true });
-        }
-        await fs.rename(tempDir, targetDir);
-        if (!quiet)
-            console.log(`✅ Moved to: ${targetDir}`);
-        // 4. Prepare
-        if (!quiet)
-            console.log(`⚙️  Preparing plugin "${name}"...`);
-        await ensurePluginReady(targetDir);
-        if (!quiet)
-            console.log(`\n🎉 Successfully installed plugin: ${name}`);
+        const parsed = parsePluginInstallSource(source);
+        const name = await installPluginFromSource(parsed, { quiet, id });
         return name;
     }
     catch (err) {
         if (!quiet)
             console.error("\n❌ Plugin installation failed:", err instanceof Error ? err.message : String(err));
-        try {
-            await fs.rm(tempDir, { recursive: true, force: true });
-        }
-        catch { /* ignore */ }
         if (!quiet)
             process.exit(1);
         throw err;
     }
 }
-/**
- * Install an agent from a source (GitHub).
- */
-async function installAgent(source) {
-    const repoUrl = source.startsWith("github:") ? `https://github.com/${source.slice(7)}.git` : `https://github.com/${source}.git`;
-    const tempDir = path.join(tmpdir(), `openbot-agent-install-${Date.now()}`);
+async function installAgent(source, id) {
     try {
-        console.log(`🤖 Installing agent from: ${repoUrl}`);
-        // 1. Clone to temp directory
-        execSync(`git clone --depth 1 ${repoUrl} ${tempDir}`, { stdio: "inherit" });
-        // 2. Identify name from agent.yaml
-        const config = await readAgentConfig(tempDir);
-        const name = config.name || path.basename(source.replace(".git", ""));
-        const baseDir = resolvePath(DEFAULT_BASE_DIR);
-        const targetDir = path.join(baseDir, "agents", name);
-        // 3. Move to target directory
-        await fs.mkdir(path.dirname(targetDir), { recursive: true });
-        if (await fs.access(targetDir).then(() => true).catch(() => false)) {
-            console.log(`⚠️  Agent "${name}" already exists. Overwriting...`);
-            await fs.rm(targetDir, { recursive: true, force: true });
-        }
-        await fs.rename(tempDir, targetDir);
-        console.log(`✅ Moved to: ${targetDir}`);
-        // 4. Recursive plugin installation
-        if (config.plugins && Array.isArray(config.plugins)) {
-            for (const pluginItem of config.plugins) {
-                const pluginName = typeof pluginItem === "string" ? pluginItem : pluginItem.name;
-                // Skip built-in plugins
-                if (["shell", "file-system"].includes(pluginName))
-                    continue;
-                // Check if plugin exists locally
-                const pluginPath = path.join(baseDir, "plugins", pluginName);
-                const existsLocally = await fs.access(pluginPath).then(() => true).catch(() => false);
-                if (!existsLocally) {
-                    console.log(`🔍 Agent needs plugin "${pluginName}". Searching...`);
-                    // Try GitHub
-                    const ghRepo = `meetopenbot/plugin-${pluginName}`;
-                    if (checkGitHubRepo(ghRepo)) {
-                        await installPlugin(ghRepo);
-                        continue;
-                    }
-                    // Try NPM
-                    const npmPkg = `@melony/plugin-${pluginName}`;
-                    if (checkNpmPackage(npmPkg)) {
-                        await installPlugin(npmPkg);
-                        continue;
-                    }
-                    console.warn(`⚠️  Could not find plugin "${pluginName}" for agent "${name}". You may need to install it manually.`);
-                }
-            }
-        }
-        console.log(`\n🎉 Successfully installed agent: ${name}`);
+        const parsed = parseAgentInstallSource(source);
+        const name = await installAgentFromSource(parsed, { id });
         return name;
     }
     catch (err) {
         console.error("\n❌ Agent installation failed:", err instanceof Error ? err.message : String(err));
-        try {
-            await fs.rm(tempDir, { recursive: true, force: true });
-        }
-        catch { /* ignore */ }
         process.exit(1);
     }
 }
+function shellEscape(arg) {
+    return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
 program
     .command("configure")
     .description("Configure OpenBot model and settings")
@@ -216,6 +103,8 @@ program
     console.log("Alternatively, you can set the environment variable:");
     console.log(provider === "openai" ? "  export OPENAI_API_KEY=your-key" : "  export ANTHROPIC_API_KEY=your-key");
     console.log("------------------------------------------");
+    console.log("\n🚀 TIP: Use 'openbot up' to start the server and web UI together.");
+    console.log("------------------------------------------\n");
     rl.close();
 });
 program
@@ -227,6 +116,43 @@ program
     .action(async (options) => {
     await startServer(options);
 });
+program
+    .command("up")
+    .description("Start OpenBot server and web dashboard together")
+    .option("-p, --port <number>", "Port to listen on")
+    .option("--openai-api-key <key>", "OpenAI API Key")
+    .option("--anthropic-api-key <key>", "Anthropic API Key")
+    .action(async (options) => {
+    const serverArgs = ["openbot", "server"];
+    if (options.port)
+        serverArgs.push("--port", String(options.port));
+    if (options.openaiApiKey)
+        serverArgs.push("--openai-api-key", options.openaiApiKey);
+    if (options.anthropicApiKey)
+        serverArgs.push("--anthropic-api-key", options.anthropicApiKey);
+    const serverCommand = serverArgs.map(shellEscape).join(" ");
+    await new Promise((resolve, reject) => {
+        const child = spawn("npx", [
+            "-y",
+            "concurrently",
+            "--kill-others",
+            "--names",
+            "SERVER,WEBUI",
+            "--prefix",
+            "{name}",
+            "--prefix-colors",
+            "blue.bold,green.bold",
+            serverCommand,
+            "openbot-web",
+        ], { stdio: "inherit" });
+        child.on("error", reject);
+        child.on("exit", (code) => {
+            if (typeof code === "number")
+                process.exitCode = code;
+            resolve();
+        });
+    });
+});
 program
     .command("add <name>")
     .description("Add an agent or plugin by name (auto-resolves to GitHub/NPM)")
@@ -234,27 +160,29 @@ program
     // 1. Try as Agent
     const agentRepo = `meetopenbot/agent-${name}`;
     if (checkGitHubRepo(agentRepo)) {
-        await installAgent(agentRepo);
+        await installAgent(agentRepo, `agent-${name}`);
         return;
     }
     // 2. Try as Plugin
     const baseDir = resolvePath(DEFAULT_BASE_DIR);
+    const agentPath = path.join(baseDir, "agents", name);
     const pluginPath = path.join(baseDir, "plugins", name);
-    const existsLocally = await fs.access(pluginPath).then(() => true).catch(() => false);
-    if (existsLocally) {
-        console.log(`✅ Plugin "${name}" is already installed locally.`);
+    const agentExists = await fs.access(agentPath).then(() => true).catch(() => false);
+    const pluginExists = await fs.access(pluginPath).then(() => true).catch(() => false);
+    if (agentExists || pluginExists) {
+        console.log(`✅ Agent or Plugin "${name}" is already installed locally.`);
         return;
     }
     // Check GitHub Plugin
     const pluginGhRepo = `meetopenbot/plugin-${name}`;
     if (checkGitHubRepo(pluginGhRepo)) {
-        await installPlugin(pluginGhRepo);
+        await installPlugin(pluginGhRepo, `plugin-${name}`);
         return;
     }
     // Check NPM Plugin
     const pluginNpmPkg = `@melony/plugin-${name}`;
     if (checkNpmPackage(pluginNpmPkg)) {
-        await installPlugin(pluginNpmPkg);
+        await installPlugin(pluginNpmPkg, `plugin-${name}`);
         return;
     }
     console.error(`❌ Could not find agent or plugin named "${name}" in official repositories.`);
@@ -302,4 +230,46 @@ plugin
     }
     console.log("------------------------------------------\n");
 });
+const agent = program.command("agent").description("Manage OpenBot agents");
+agent
+    .command("install <source>")
+    .description("Install a custom agent from GitHub (user/repo) or a local path")
+    .action(async (source) => {
+    await installAgent(source);
+});
+agent
+    .command("list")
+    .description("List all installed custom agents")
+    .action(async () => {
+    const baseDir = resolvePath(DEFAULT_BASE_DIR);
+    const agentsDir = path.join(baseDir, "agents");
+    try {
+        await fs.access(agentsDir);
+    }
+    catch {
+        console.log("No custom agents found.");
+        return;
+    }
+    const entries = await fs.readdir(agentsDir, { withFileTypes: true });
+    const agents = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        if (entry.name.startsWith(".") || entry.name.startsWith("_"))
+            continue;
+        const agentDir = path.join(agentsDir, entry.name);
+        const { name, version, description } = await getPluginMetadata(agentDir);
+        agents.push({ name, version, description });
+    }
+    if (agents.length === 0) {
+        console.log("No custom agents found.");
+        return;
+    }
+    console.log("\n🤖 Installed Custom Agents:");
+    console.log("------------------------------------------");
+    for (const a of agents) {
+        console.log(`${a.name.padEnd(20)} (${a.version}) - ${a.description}`);
+    }
+    console.log("------------------------------------------\n");
+});
 program.parse();

package/dist/config.js

@@ -2,6 +2,8 @@ import fs from "node:fs";
 import path from "node:path";
 import os from "node:os";
 export const DEFAULT_BASE_DIR = "~/.openbot";
+export const DEFAULT_PLUGINS_DIR = "plugins";
+export const DEFAULT_AGENTS_DIR = "agents";
 export function loadConfig() {
     const configPath = path.join(os.homedir(), ".openbot", "config.json");
     if (fs.existsSync(configPath)) {
@@ -31,3 +33,21 @@ export function isConfigured() {
 export function resolvePath(p) {
     return p.startsWith("~/") ? path.join(os.homedir(), p.slice(2)) : path.resolve(p);
 }
+export const DEFAULT_AGENT_MD = `---
+name: Agent
+description: A specialized AI agent
+plugins:
+  - shell
+  - file-system
+---
+
+# Agent Profile
+
+You are a specialized AI agent within the OpenBot system.
+Your role is defined by your configuration and the tools you have access to.
+
+## Persona
+- Helpful and precise
+- Focused on my specific domain
+- Professional in all interactions
+`;

package/dist/core/agents.js

@@ -0,0 +1,41 @@
+import { osAgent } from "../agents/os-agent.js";
+import { agentCreatorAgent } from "../agents/agent-creator.js";
+import { plannerAgent } from "../agents/planner-agent.js";
+import { shellToolDefinitions } from "../plugins/shell/index.js";
+import { fileSystemToolDefinitions } from "../plugins/file-system/index.js";
+import { AgentRegistry, discoverYamlAgents, discoverTsAgents } from "../registry/index.js";
+import path from "node:path";
+export async function setupAgentRegistry(resolvedBaseDir, pluginRegistry, model, options) {
+    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 }),
+    });
+    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 }),
+    });
+    agentRegistry.register({
+        name: "planner-agent",
+        description: "Creates concise execution plans from user intent for OpenBot to run.",
+        plugin: plannerAgent({ model }),
+    });
+    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);
+    }
+    return agentRegistry;
+}

package/dist/core/delegation.js

@@ -0,0 +1,124 @@
+import { generateId } from "melony";
+export function setupDelegation(builder, agentRuntimes) {
+    builder.on("action:delegateTask", async function* (event, context) {
+        const { agent: agentName, toolCallId, task, attachments } = event.data;
+        const agentRuntime = agentRuntimes.get(agentName);
+        // If the agent is not found, return an error
+        if (!agentRuntime) {
+            yield {
+                type: "action:result",
+                data: {
+                    action: "delegateTask",
+                    result: `Error: Agent "${agentName}" not found.`,
+                    toolCallId,
+                },
+            };
+            return;
+        }
+        const delegationId = `del_${generateId()}`;
+        // Signal delegation start for UI
+        yield {
+            type: "delegation:start",
+            meta: { delegationId, agentName },
+            data: { agent: agentName, task },
+        };
+        // Initialize agent isolated state if not present
+        const state = context.state;
+        if (!state.agentStates)
+            state.agentStates = {};
+        if (!state.agentStates[agentName])
+            state.agentStates[agentName] = {};
+        const agentState = state.agentStates[agentName];
+        const agentIterator = agentRuntime.run({
+            type: "agent:input",
+            data: { content: task, attachments },
+        }, {
+            runId: delegationId,
+            state: agentState,
+        });
+        let lastAgentOutput = "";
+        try {
+            for await (const agentEvent of agentIterator) {
+                // Forward agent events to the main runtime so the user sees progress.
+                // We SKIP forwarding 'agent:input' because it triggers the manager's LLM again.
+                // Instead, we yield it as 'agent:sub-input' for logging/monitoring.
+                if (agentEvent.type === "agent:input") {
+                    yield {
+                        ...agentEvent,
+                        type: "agent:sub-input",
+                        meta: { ...agentEvent.meta, delegationId, agentName },
+                    };
+                    continue;
+                }
+                // We wrap sub-agent actions to avoid triggering manager handlers if they share names.
+                if (agentEvent.type.startsWith("action:") && agentEvent.type !== "action:result") {
+                    yield {
+                        ...agentEvent,
+                        type: "agent:sub-action",
+                        meta: { ...agentEvent.meta, delegationId, agentName },
+                        data: { ...agentEvent.data, originalType: agentEvent.type },
+                    };
+                    continue;
+                }
+                // Wrap action results to avoid confusion with manager action results.
+                if (agentEvent.type === "action:result") {
+                    yield {
+                        ...agentEvent,
+                        type: "agent:sub-action-result",
+                        meta: { ...agentEvent.meta, delegationId, agentName },
+                    };
+                    continue;
+                }
+                // Wrap usage updates to avoid confusion with manager usage.
+                if (agentEvent.type === "usage:update") {
+                    yield {
+                        ...agentEvent,
+                        type: "agent:sub-usage",
+                        meta: { ...agentEvent.meta, delegationId, agentName },
+                    };
+                    continue;
+                }
+                // Pass through other events but tag them with delegationId and agentName in meta
+                yield {
+                    ...agentEvent,
+                    meta: { ...agentEvent.meta, delegationId, agentName },
+                };
+                // accumulate agent output
+                if (agentEvent.type === "agent:output") {
+                    const agentOutput = agentEvent.data;
+                    // THIS NEEDS TO BE IMPROVED. WE NEED TO KEEP A SINGLE AGENT OUTPUT VARIABLE.
+                    const value = agentOutput?.result ?? agentOutput?.content ?? agentOutput?.message;
+                    if (typeof value === "string") {
+                        if (lastAgentOutput)
+                            lastAgentOutput += "\n\n";
+                        lastAgentOutput += value;
+                    }
+                    else if (typeof value === "object" && value !== null) {
+                        if (lastAgentOutput)
+                            lastAgentOutput += "\n\n";
+                        lastAgentOutput += JSON.stringify(value, null, 2);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error(`[delegation] Error running agent "${agentName}":`, error);
+            lastAgentOutput = `Error executing task: ${error.message}`;
+        }
+        // Signal delegation end for UI
+        yield {
+            type: "delegation:end",
+            meta: { delegationId, agentName },
+            data: { agent: agentName, result: lastAgentOutput || "Task completed." },
+        };
+        // Feedback the result back to the manager
+        yield {
+            type: "action:result",
+            data: {
+                action: "delegateTask",
+                result: lastAgentOutput || "Task completed with no output.",
+                toolCallId,
+            },
+        };
+    });
+}

package/dist/core/manager.js

@@ -0,0 +1,73 @@
+import { z } from "zod";
+import { memoryPlugin, memoryToolDefinitions, createMemoryPromptBuilder } from "../plugins/memory/index.js";
+import { topicAgent } from "../agents/topic-agent.js";
+import { llmPlugin } from "../plugins/llm/index.js";
+export function createManagerPlugin(model, resolvedModelId, resolvedBaseDir, registry) {
+    const agentNames = registry.getAgentNames();
+    const allAgents = registry.getAgents();
+    const buildMemoryPrompt = createMemoryPromptBuilder(resolvedBaseDir);
+    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");
+    return (builder) => {
+        builder
+            .use(memoryPlugin({
+            baseDir: resolvedBaseDir,
+        }))
+            .use(topicAgent({ model: model }))
+            .use(llmPlugin({
+            model: model,
+            modelId: resolvedModelId,
+            usageScope: "manager",
+            system: async (context) => {
+                const memoryPrompt = await buildMemoryPrompt(context);
+                return `
+
+<orchestrator>
+Your goal is to solve user requests by delegating tasks to expert sub-agents.
+
+**Directives**:
+1. **Delegate**: Use \`delegateTask\` for any task matching an agent's description.
+2. **Plan**: For multi-step tasks, use \`planner-agent\` first to create a roadmap.
+3. **Context**: Provide a clear, detailed task for the sub-agent. Pass any relevant user attachments.
+4. **Report**: Summarize the sub-agent's work concisely for the user.
+5. **Memory**: Use your memory tools (\`remember\`, \`recall\`) to maintain context across sessions.
+</orchestrator>
+
+<agents>
+${agentDescriptions}
+</agents>${memoryPrompt}`;
+            },
+            promptInputType: "agent:input",
+            actionResultInputType: "action:result",
+            completionEventType: "agent:output",
+            toolDefinitions: {
+                ...memoryToolDefinitions,
+                delegateTask: {
+                    description: `Delegate a task to a specialized expert agent.`,
+                    inputSchema: z.object({
+                        agent: z.enum(agentNames).describe("The name of the agent to use"),
+                        task: z.string().describe("The task for the agent to perform"),
+                        attachments: z.array(z.object({
+                            id: z.string(),
+                            name: z.string(),
+                            mimeType: z.string(),
+                            size: z.number(),
+                            url: z.string(),
+                        })).optional().describe("Attachments to pass through to the agent"),
+                    }),
+                },
+            },
+        }));
+    };
+}

package/dist/core/plugins.js

@@ -0,0 +1,77 @@
+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 { osAgent } from "../agents/os-agent.js";
+import { agentCreatorAgent } from "../agents/agent-creator.js";
+import { plannerAgent } from "../agents/planner-agent.js";
+import { PluginRegistry, discoverPlugins } from "../registry/index.js";
+import path from "node:path";
+/**
+ * Build the unified plugin registry.
+ *
+ * Registers built-in tools and agents, then discovers community
+ * plugins (tools + agents) from ~/.openbot/plugins/.
+ */
+export async function setupPluginRegistry(resolvedBaseDir, model, options) {
+    const registry = new PluginRegistry();
+    // ── Built-in tools ───────────────────────────────────────────────
+    registry.register({
+        name: "shell",
+        description: "Execute shell commands",
+        type: "tool",
+        toolDefinitions: shellToolDefinitions,
+        plugin: () => shellPlugin({ cwd: process.cwd() }),
+        isBuiltIn: true,
+    });
+    registry.register({
+        name: "file-system",
+        description: "Read, write, list, and delete files",
+        type: "tool",
+        toolDefinitions: fileSystemToolDefinitions,
+        plugin: () => fileSystemPlugin({ baseDir: "/" }),
+        isBuiltIn: true,
+    });
+    registry.register({
+        name: "approval",
+        description: "Require user approval for specific actions",
+        type: "tool",
+        toolDefinitions: {},
+        plugin: (opts) => approvalPlugin(opts),
+        isBuiltIn: true,
+    });
+    // ── Built-in agents ──────────────────────────────────────────────
+    registry.register({
+        name: "os",
+        description: "Handles shell commands and file system operations",
+        type: "agent",
+        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 }),
+        isBuiltIn: true,
+    });
+    registry.register({
+        name: "agent-creator",
+        description: "Helps the user create and update custom OpenBot agents via natural language.",
+        type: "agent",
+        capabilities: {
+            ...Object.fromEntries(Object.entries(fileSystemToolDefinitions).map(([k, v]) => [k, v.description])),
+        },
+        plugin: agentCreatorAgent({ model }),
+        isBuiltIn: true,
+    });
+    registry.register({
+        name: "planner-agent",
+        description: "Creates concise execution plans from user intent for OpenBot to run.",
+        type: "agent",
+        plugin: plannerAgent({ model }),
+        isBuiltIn: true,
+    });
+    // ── Custom agents and plugins ────────────────────────────────────
+    const agentsDir = path.join(resolvedBaseDir, "agents");
+    const pluginsDir = path.join(resolvedBaseDir, "plugins");
+    await discoverPlugins(pluginsDir, registry, model, options);
+    await discoverPlugins(agentsDir, registry, model, options);
+    return registry;
+}