openbot 0.1.25 → 0.1.26

package/dist/cli.js

@@ -7,12 +7,167 @@ import { execSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { saveConfig, resolvePath, DEFAULT_BASE_DIR } from "./config.js";
 import { startServer } from "./server.js";
-import { ensurePluginReady } from "./registry/plugin-loader.js";
+import { ensurePluginReady, getPluginMetadata } from "./registry/plugin-loader.js";
+import { readAgentConfig } from "./registry/yaml-agent-loader.js";
 const program = new Command();
 program
     .name("openbot")
     .description("OpenBot CLI - Secure and easy configuration")
-    .version("0.1.23");
+    .version("0.1.26");
+/**
+ * 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()}`);
+    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}`);
+        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()}`);
+    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}`);
+        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);
+    }
+}
 program
     .command("configure")
     .description("Configure OpenBot model and settings")
@@ -72,62 +227,45 @@ program
     .action(async (options) => {
     await startServer(options);
 });
+program
+    .command("add <name>")
+    .description("Add an agent or plugin by name (auto-resolves to GitHub/NPM)")
+    .action(async (name) => {
+    // 1. Try as Agent
+    const agentRepo = `meetopenbot/agent-${name}`;
+    if (checkGitHubRepo(agentRepo)) {
+        await installAgent(agentRepo);
+        return;
+    }
+    // 2. Try as Plugin
+    const baseDir = resolvePath(DEFAULT_BASE_DIR);
+    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.`);
+        return;
+    }
+    // Check GitHub Plugin
+    const pluginGhRepo = `meetopenbot/plugin-${name}`;
+    if (checkGitHubRepo(pluginGhRepo)) {
+        await installPlugin(pluginGhRepo);
+        return;
+    }
+    // Check NPM Plugin
+    const pluginNpmPkg = `@melony/plugin-${name}`;
+    if (checkNpmPackage(pluginNpmPkg)) {
+        await installPlugin(pluginNpmPkg);
+        return;
+    }
+    console.error(`❌ Could not find agent or plugin named "${name}" in official repositories.`);
+    process.exit(1);
+});
 const plugin = program.command("plugin").description("Manage OpenBot plugins");
 plugin
     .command("install <source>")
     .description("Install a shared plugin from GitHub (user/repo) or a local path")
     .action(async (source) => {
-    const isGitHub = source.includes("/") && !source.startsWith("/") && !source.startsWith(".");
-    const repoUrl = isGitHub ? `https://github.com/${source}.git` : source;
-    const tempDir = path.join(tmpdir(), `openbot-plugin-install-${Date.now()}`);
-    try {
-        console.log(`📦 Installing plugin from: ${repoUrl}`);
-        // 1. Clone or copy to temp directory
-        if (isGitHub) {
-            execSync(`git clone --depth 1 ${repoUrl} ${tempDir}`, { stdio: "inherit" });
-        }
-        else {
-            const absoluteSource = path.resolve(source);
-            await fs.mkdir(tempDir, { recursive: true });
-            execSync(`cp -R ${absoluteSource}/. ${tempDir}`, { stdio: "inherit" });
-        }
-        // 2. Identify name from package.json
-        let name = path.basename(source.replace(".git", ""));
-        const pkgPath = path.join(tempDir, "package.json");
-        if (await fs.access(pkgPath).then(() => true).catch(() => false)) {
-            try {
-                const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
-                if (pkg.name)
-                    name = pkg.name.split("/").pop(); // Use last part of scoped names
-            }
-            catch {
-                // Fallback to source basename
-            }
-        }
-        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)) {
-            console.log(`⚠️  Plugin "${name}" already exists. Overwriting...`);
-            await fs.rm(targetDir, { recursive: true, force: true });
-        }
-        await fs.rename(tempDir, targetDir);
-        console.log(`✅ Moved to: ${targetDir}`);
-        // 4. Prepare
-        console.log(`⚙️  Preparing plugin "${name}"...`);
-        await ensurePluginReady(targetDir);
-        console.log(`\n🎉 Successfully installed plugin: ${name}`);
-        console.log(`This plugin is now available to all agents.`);
-    }
-    catch (err) {
-        console.error("\n❌ Plugin installation failed:", err instanceof Error ? err.message : String(err));
-        try {
-            await fs.rm(tempDir, { recursive: true, force: true });
-        }
-        catch { /* ignore */ }
-        process.exit(1);
-    }
+    await installPlugin(source);
 });
 plugin
     .command("list")
@@ -149,18 +287,9 @@ plugin
             continue;
         if (entry.name.startsWith(".") || entry.name.startsWith("_"))
             continue;
-        const pkgPath = path.join(pluginsDir, entry.name, "package.json");
-        let description = "No description";
-        let version = "0.0.0";
-        try {
-            const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
-            description = pkg.description || description;
-            version = pkg.version || version;
-        }
-        catch {
-            // Use defaults
-        }
-        plugins.push({ name: entry.name, version, description });
+        const pluginDir = path.join(pluginsDir, entry.name);
+        const { name, version, description } = await getPluginMetadata(pluginDir);
+        plugins.push({ name, version, description });
     }
     if (plugins.length === 0) {
         console.log("No shared plugins found.");

package/dist/handlers/settings.js

@@ -1,5 +1,7 @@
 import { saveConfig } from "../config.js";
 import { tabOnlyUI } from "../ui/layout.js";
+import { exec } from "node:child_process";
+import os from "node:os";
 /**
  * Handle settings updates (like API keys)
  */
@@ -27,3 +29,19 @@ export async function* updateSettingsHandler(event, { state }) {
         };
     }
 }
+/**
+ * Handle opening an agent's folder in the native file explorer
+ */
+export async function* openAgentFolderHandler(event) {
+    const { folder } = event.data;
+    if (folder) {
+        const command = os.platform() === "win32" ? `explorer "${folder}"` :
+            os.platform() === "darwin" ? `open "${folder}"` :
+                `xdg-open "${folder}"`;
+        exec(command, (error) => {
+            if (error) {
+                console.error(`Failed to open folder: ${error.message}`);
+            }
+        });
+    }
+}

package/dist/open-bot.js

@@ -6,7 +6,7 @@ import { llmPlugin } from "./plugins/llm/index.js";
 import { initHandler } from "./handlers/init.js";
 import { sessionChangeHandler } from "./handlers/session-change.js";
 import { tabChangeHandler } from "./handlers/tab-change.js";
-import { updateSettingsHandler } from "./handlers/settings.js";
+import { updateSettingsHandler, openAgentFolderHandler } from "./handlers/settings.js";
 import { loadConfig, resolvePath, DEFAULT_BASE_DIR } from "./config.js";
 import { createModel } from "./models.js";
 import path from "node:path";
@@ -30,7 +30,6 @@ export async function createOpenBot(options) {
     const baseDir = config.baseDir || DEFAULT_BASE_DIR;
     const resolvedBaseDir = resolvePath(baseDir);
     const model = createModel(options);
-    const userDataDir = path.join(resolvedBaseDir, "browser-data");
     // ─── Plugin Registry ─────────────────────────────────────────────
     // Register built-in plugins so YAML agents can reference them by name.
     const pluginRegistry = new PluginRegistry();
@@ -195,6 +194,7 @@ Example: If the user asks to "check the weather", and you see a 'browser' agent,
         .on("init", initHandler)
         .on("sessionChange", sessionChangeHandler)
         .on("tabChange", tabChangeHandler)
-        .on("action:updateSettings", updateSettingsHandler);
+        .on("action:updateSettings", updateSettingsHandler)
+        .on("action:openAgentFolder", openAgentFolderHandler);
     return app;
 }

package/dist/registry/index.js

@@ -1,4 +1,4 @@
 export { PluginRegistry } from "./plugin-registry.js";
 export { AgentRegistry } from "./agent-registry.js";
-export { discoverYamlAgents } from "./yaml-agent-loader.js";
+export { discoverYamlAgents, listYamlAgents } from "./yaml-agent-loader.js";
 export { loadPluginsFromDir } from "./plugin-loader.js";

package/dist/registry/plugin-loader.js

@@ -2,6 +2,28 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { pathToFileURL } from "node:url";
 import { execSync } from "node:child_process";
+/**
+ * Get metadata (name, description, version) from a plugin directory.
+ */
+export async function getPluginMetadata(pluginDir) {
+    const pkgPath = path.join(pluginDir, "package.json");
+    const hasPackageJson = await fs.access(pkgPath).then(() => true).catch(() => false);
+    let name = path.basename(pluginDir);
+    let description = "No description";
+    let version = "0.0.0";
+    if (hasPackageJson) {
+        try {
+            const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
+            name = (pkg.name?.split("/").pop()) || name;
+            description = pkg.description || description;
+            version = pkg.version || version;
+        }
+        catch {
+            // Fallback to defaults
+        }
+    }
+    return { name, description, version };
+}
 /**
  * Ensure a plugin is ready to run by installing dependencies and building if necessary.
  */

package/dist/registry/yaml-agent-loader.js

@@ -25,6 +25,50 @@ function resolveConfigPaths(config) {
     }
     return config;
 }
+/**
+ * Read and parse an agent.yaml file from a directory.
+ */
+export async function readAgentConfig(agentDir) {
+    const yamlPath = path.join(agentDir, "agent.yaml");
+    const content = await fs.readFile(yamlPath, "utf-8");
+    return yaml.load(content);
+}
+/**
+ * Discover YAML-defined agents from a directory without loading plugins.
+ *
+ * @param agentsDir  Absolute path to the agents directory (e.g. ~/.openbot/agents)
+ * @returns Array of agent metadata
+ */
+export async function listYamlAgents(agentsDir) {
+    const agents = [];
+    try {
+        const entries = await fs.readdir(agentsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith(".") || entry.name.startsWith("_"))
+                continue;
+            const agentDir = path.join(agentsDir, entry.name);
+            try {
+                const config = await readAgentConfig(agentDir);
+                if (config.name && config.description) {
+                    agents.push({
+                        name: config.name,
+                        description: config.description,
+                        folder: agentDir,
+                    });
+                }
+            }
+            catch {
+                // Skip invalid agents
+            }
+        }
+    }
+    catch {
+        // Agents directory doesn't exist
+    }
+    return agents;
+}
 /**
  * Discover and load YAML-defined agents from a directory.
  *
@@ -56,8 +100,7 @@ export async function discoverYamlAgents(agentsDir, pluginRegistry, defaultModel
             const yamlPath = path.join(agentsDir, entry.name, "agent.yaml");
             const agentDir = path.join(agentsDir, entry.name);
             try {
-                const content = await fs.readFile(yamlPath, "utf-8");
-                const config = yaml.load(content);
+                const config = await readAgentConfig(agentDir);
                 // Validate required fields
                 if (!config.name || !config.description || !config.plugins?.length || !config.systemPrompt) {
                     console.warn(`[agents] "${entry.name}/agent.yaml": missing required fields (name, description, plugins, systemPrompt) — skipping`);

package/dist/ui/settings.js

@@ -1,75 +1,106 @@
 import { ui } from "@melony/ui-kit";
-import { loadConfig } from "../config.js";
+import { loadConfig, resolvePath, DEFAULT_BASE_DIR } from "../config.js";
+import { listYamlAgents } from "../registry/index.js";
+import path from "node:path";
 export const settingsUI = async () => {
     const config = loadConfig();
+    const baseDir = config.baseDir || DEFAULT_BASE_DIR;
+    const resolvedBaseDir = resolvePath(baseDir);
+    const agentsDir = path.join(resolvedBaseDir, "agents");
     const hasOpenAIKey = !!config.openaiApiKey;
     const hasAnthropicKey = !!config.anthropicApiKey;
-    return ui.form({
-        onSubmitAction: {
-            type: "action:updateSettings",
-            data: {}
-        }
+    const agents = await listYamlAgents(agentsDir);
+    return ui.box({
+        width: "full",
+        height: "full",
+        overflow: "auto",
     }, [
-        ui.box({
-            width: "full",
-            height: "full",
-            padding: "xl",
-            background: "background",
-        }, [
-            ui.col({ gap: "xl", width: "full" }, [
-                ui.col({ gap: "xs" }, [
-                    ui.heading("Settings", 2),
-                    ui.text("Manage your OpenBot configuration", { color: "mutedForeground" }),
-                ]),
-                ui.divider(),
-                ui.col({ gap: "md" }, [
-                    ui.heading("Model Configuration", 4),
-                    ui.col({ gap: "sm" }, [
-                        ui.input("model", undefined, {
-                            placeholder: "e.g. gpt-4o-mini",
-                            width: "full",
-                            defaultValue: config.model || "gpt-4o-mini"
-                        }),
-                    ]),
-                ]),
-                ui.col({ gap: "md" }, [
-                    ui.heading("API Keys", 4),
-                    ui.col({ gap: "lg" }, [
-                        // OpenAI Key
+        ui.col({ padding: "xl", gap: "xl", width: "full", flex: 1 }, [
+            ui.col({ gap: "xs" }, [
+                ui.heading("Settings", 2),
+                ui.text("Manage your OpenBot configuration", { color: "mutedForeground" }),
+            ]),
+            ui.divider(),
+            ui.form({
+                onSubmitAction: {
+                    type: "action:updateSettings",
+                    data: {}
+                }
+            }, [
+                ui.col({ gap: "xl" }, [
+                    ui.col({ gap: "md" }, [
+                        ui.heading("Model Configuration", 4),
                         ui.col({ gap: "sm" }, [
-                            ui.node("label", { value: "OpenAI API Key" }),
-                            ui.input("openai_api_key", undefined, {
-                                placeholder: "sk-...",
-                                inputType: "password",
-                                defaultValue: hasOpenAIKey ? "••••••••••••••••" : "",
-                                width: "full"
+                            ui.input("model", undefined, {
+                                placeholder: "e.g. gpt-4o-mini",
+                                width: "full",
+                                defaultValue: config.model || "gpt-4o-mini"
                             }),
                         ]),
-                        // Anthropic Key
-                        ui.col({ gap: "sm" }, [
-                            ui.node("label", { value: "Anthropic API Key" }),
-                            ui.input("anthropic_api_key", undefined, {
-                                placeholder: "sk-ant-...",
-                                inputType: "password",
-                                defaultValue: hasAnthropicKey ? "••••••••••••••••" : "",
-                                width: "full"
-                            }),
+                    ]),
+                    ui.col({ gap: "md" }, [
+                        ui.heading("API Keys", 4),
+                        ui.col({ gap: "lg" }, [
+                            // OpenAI Key
+                            ui.col({ gap: "sm" }, [
+                                ui.node("label", { value: "OpenAI API Key" }),
+                                ui.input("openai_api_key", undefined, {
+                                    placeholder: "sk-...",
+                                    inputType: "password",
+                                    defaultValue: hasOpenAIKey ? "••••••••••••••••" : "",
+                                    width: "full"
+                                }),
+                            ]),
+                            // Anthropic Key
+                            ui.col({ gap: "sm" }, [
+                                ui.node("label", { value: "Anthropic API Key" }),
+                                ui.input("anthropic_api_key", undefined, {
+                                    placeholder: "sk-ant-...",
+                                    inputType: "password",
+                                    defaultValue: hasAnthropicKey ? "••••••••••••••••" : "",
+                                    width: "full"
+                                }),
+                            ])
                         ])
+                    ]),
+                    ui.col({ gap: "md" }, [
+                        ui.heading("Theme", 4),
+                        ui.themeToggle(),
+                    ]),
+                    ui.row({ justify: "end" }, [
+                        ui.button({
+                            label: "Save Settings",
+                            type: "submit",
+                            variant: "primary"
+                        })
                     ])
-                ]),
-                ui.col({ gap: "md" }, [
-                    ui.heading("Theme", 4),
-                    ui.themeToggle(),
-                ]),
-                ui.divider(),
-                ui.row({ justify: "end" }, [
-                    ui.button({
-                        label: "Save Settings",
-                        type: "submit",
-                        variant: "primary"
-                    })
                 ])
+            ]),
+            ui.divider(),
+            ui.col({ gap: "md" }, [
+                ui.heading("Installed Agents", 4),
+                ui.text("Agents installed in ~/.openbot/agents", { color: "mutedForeground", size: "sm" }),
+                ui.col({ gap: "sm" }, agents.map(agent => (ui.box({
+                    padding: "md",
+                    background: "muted",
+                }, [
+                    ui.row({ justify: "between", align: "center" }, [
+                        ui.col({ gap: "xs" }, [
+                            ui.text(agent.name, { weight: "bold" }),
+                            ui.text(agent.description, { size: "sm", color: "mutedForeground" }),
+                        ]),
+                        ui.button({
+                            label: "Open Folder",
+                            variant: "secondary",
+                            size: "sm",
+                            onClickAction: {
+                                type: "action:openAgentFolder",
+                                data: { folder: agent.folder }
+                            }
+                        })
+                    ])
+                ]))))
             ])
-        ])
+        ]),
     ]);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openbot",
-  "version": "0.1.25",
+  "version": "0.1.26",
   "private": false,
   "type": "module",
   "bin": {