openbot 0.2.5 → 0.2.6

package/dist/cli.js

@@ -3,19 +3,34 @@ 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 { spawn } from "node:child_process";
 import { saveConfig, resolvePath, DEFAULT_BASE_DIR } from "./config.js";
 import { startServer } from "./server.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.5");
-async function installPlugin(source, quiet = false) {
+    .version("0.2.6");
+async function installPlugin(source, id, quiet = false) {
     try {
         const parsed = parsePluginInstallSource(source);
-        const name = await installPluginFromSource(parsed, { quiet });
+        const name = await installPluginFromSource(parsed, { quiet, id });
         return name;
     }
     catch (err) {
@@ -26,10 +41,10 @@ async function installPlugin(source, quiet = false) {
         throw err;
     }
 }
-async function installAgent(source) {
+async function installAgent(source, id) {
     try {
         const parsed = parseAgentInstallSource(source);
-        const name = await installAgentFromSource(parsed);
+        const name = await installAgentFromSource(parsed, { id });
         return name;
     }
     catch (err) {
@@ -37,6 +52,9 @@ async function installAgent(source) {
         process.exit(1);
     }
 }
+function shellEscape(arg) {
+    return `'${arg.replace(/'/g, `'\\''`)}'`;
+}
 program
     .command("configure")
     .description("Configure OpenBot model and settings")
@@ -85,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
@@ -96,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)")
@@ -103,7 +160,7 @@ 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
@@ -119,13 +176,13 @@ program
     // 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.`);

package/dist/core/plugins.js

@@ -71,7 +71,7 @@ export async function setupPluginRegistry(resolvedBaseDir, model, options) {
     // ── Custom agents and plugins ────────────────────────────────────
     const agentsDir = path.join(resolvedBaseDir, "agents");
     const pluginsDir = path.join(resolvedBaseDir, "plugins");
-    await discoverPlugins(agentsDir, registry, model, options);
     await discoverPlugins(pluginsDir, registry, model, options);
+    await discoverPlugins(agentsDir, registry, model, options);
     return registry;
 }

package/dist/installers.js

@@ -3,7 +3,7 @@ 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";
+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, {
@@ -15,9 +15,6 @@ 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;
@@ -28,7 +25,8 @@ async function directoryExists(targetPath) {
 }
 export function checkGitHubRepo(repo) {
     try {
-        run("git", ["ls-remote", githubRepoToCloneUrl(repo)], { quiet: true });
+        const url = `https://github.com/${repo}.git`;
+        run("git", ["ls-remote", url], { quiet: true });
         return true;
     }
     catch {
@@ -44,7 +42,7 @@ export function checkNpmPackage(pkg) {
         return false;
     }
 }
-export function parsePluginInstallSource(source) {
+export function parseSource(source) {
     const normalized = source.trim();
     const isGithub = (normalized.includes("/") || normalized.startsWith("github:"))
         && !normalized.startsWith("/")
@@ -64,26 +62,33 @@ export function parsePluginInstallSource(source) {
     }
     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 = {}) {
+export async function installExtension(type, 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 });
+    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") {
-            log(`📦 Installing plugin from: ${githubRepoToCloneUrl(source.value)}`, quiet);
-            run("git", ["clone", "--depth", "1", githubRepoToCloneUrl(source.value), tempDir], { quiet });
+            const url = `https://github.com/${source.value}.git`;
+            run("git", ["clone", "--depth", "1", url, 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);
@@ -93,55 +98,34 @@ export async function installPluginFromSource(source, options = {}) {
             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);
+            log(`⚠️  Removing existing folder: ${targetDir}`, quiet);
             await fs.rm(targetDir, { recursive: true, force: true });
         }
         await fs.rename(tempDir, targetDir);
-        log(`✅ Moved to: ${targetDir}`, quiet);
-        log(`⚙️  Preparing plugin "${name}"...`, quiet);
+        log(`✅ Installed to: ${targetDir}`, quiet);
+        // Prepare dependencies and build
         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 });
+        // If it's an agent, check for missing plugins
+        if (type === "agent") {
+            await installMissingPluginsFromAgent(targetDir, { quiet });
         }
-        await fs.rename(tempDir, targetDir);
-        log(`✅ Moved to: ${targetDir}`, quiet);
-        await installMissingPluginsFromAgent(targetDir, { quiet });
-        log(`\n🎉 Successfully installed agent: ${name}`, quiet);
-        return name;
+        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);
@@ -150,21 +134,23 @@ export async function installMissingPluginsFromAgent(agentFolder, options = {})
         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 existsLocally = await directoryExists(pluginPath);
-        if (existsLocally)
+        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 installPluginFromSource({ type: "github", value: ghRepo }, { quiet });
+            await installExtension("plugin", { type: "github", value: ghRepo }, { quiet });
             continue;
         }
         const npmPkg = `@melony/plugin-${pluginName}`;
         if (checkNpmPackage(npmPkg)) {
-            await installPluginFromSource({ type: "npm", value: npmPkg }, { quiet });
+            await installExtension("plugin", { type: "npm", value: npmPkg }, { quiet });
             continue;
         }
-        log(`⚠️  Could not find plugin "${pluginName}" for this agent. You may need to install it manually.`, quiet);
+        log(`⚠️  Could not find plugin "${pluginName}" for this agent.`, quiet);
     }
 }

package/dist/marketplace.js

@@ -67,7 +67,7 @@ export async function installMarketplaceAgent(agentId) {
     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 });
+    const installedName = await installAgentFromSource({ type: "github", value: agent.source.value }, { id: agent.id });
     return { installedName, agent };
 }
 export async function installMarketplacePlugin(pluginId) {
@@ -75,6 +75,6 @@ export async function installMarketplacePlugin(pluginId) {
     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);
+    const installedName = await installPluginFromSource(plugin.source, { id: plugin.id });
     return { installedName, plugin };
 }

package/dist/registry/plugin-loader.js

@@ -8,6 +8,13 @@ import { llmPlugin } from "../plugins/llm/index.js";
 import { createModel } from "../models.js";
 import { resolvePath, DEFAULT_AGENT_MD } from "../config.js";
 // ── Helpers ──────────────────────────────────────────────────────────
+function toTitleCaseFromSlug(value) {
+    return value
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ") || "Agent";
+}
 async function fileExists(filePath) {
     return fs.access(filePath).then(() => true).catch(() => false);
 }
@@ -217,7 +224,11 @@ export async function discoverPlugins(dir, registry, defaultModel, options) {
             const entryData = module.plugin || module.default || module.entry;
             if (codeAgentDef && typeof codeAgentDef.factory === "function") {
                 const meta = await getPluginMetadata(pluginDir);
-                const name = codeAgentDef.name || meta.name || "Unnamed Agent";
+                const folderName = path.basename(pluginDir);
+                let name = codeAgentDef.name || meta.name;
+                if (!name || /^Unnamed\s+(Plugin|Tool|Agent)$/i.test(name)) {
+                    name = toTitleCaseFromSlug(folderName);
+                }
                 const description = codeAgentDef.description || meta.description || "Code Agent";
                 registry.register({
                     name,
@@ -232,8 +243,13 @@ export async function discoverPlugins(dir, registry, defaultModel, options) {
             }
             else if (entryData && typeof entryData.factory === "function") {
                 const meta = await getPluginMetadata(pluginDir);
+                const folderName = path.basename(pluginDir);
+                let name = entryData.name || meta.name;
+                if (!name || /^Unnamed\s+(Plugin|Tool|Agent)$/i.test(name)) {
+                    name = toTitleCaseFromSlug(folderName);
+                }
                 const pluginEntry = {
-                    name: entryData.name || meta.name || "Unnamed Tool",
+                    name,
                     description: entryData.description || meta.description || "Tool plugin",
                     type: "tool",
                     plugin: entryData.factory,
@@ -266,7 +282,10 @@ export async function discoverPlugins(dir, registry, defaultModel, options) {
                 if (definition && typeof definition.factory === "function") {
                     const config = await readAgentConfig(agentDir);
                     const meta = await getPluginMetadata(agentDir);
-                    const name = config.name || definition.name || meta.name || "Unnamed Agent";
+                    let name = config.name || definition.name || meta.name;
+                    if (!name || /^Unnamed\s+(Plugin|Tool|Agent)$/i.test(name)) {
+                        name = toTitleCaseFromSlug(folderName);
+                    }
                     const description = definition.description || config.description || "TS Agent";
                     registry.register({
                         name,
@@ -284,7 +303,10 @@ export async function discoverPlugins(dir, registry, defaultModel, options) {
                 // Declarative Agent — AGENT.md only, auto-wrapped with llmPlugin.
                 const config = await readAgentConfig(agentDir);
                 const meta = await getPluginMetadata(agentDir);
-                const resolvedName = config.name || meta.name || "Unnamed Agent";
+                let resolvedName = config.name || meta.name;
+                if (!resolvedName || /^Unnamed\s+(Plugin|Tool|Agent)$/i.test(resolvedName)) {
+                    resolvedName = toTitleCaseFromSlug(folderName);
+                }
                 const resolvedDescription = config.description || meta.description || "No description";
                 const agentModel = config.model
                     ? createModel({ ...options, model: config.model })

package/dist/server.js

@@ -7,6 +7,7 @@ import { createOpenBot } from "./open-bot.js";
 import { loadConfig, saveConfig, isConfigured, resolvePath, DEFAULT_BASE_DIR } from "./config.js";
 import { loadSession, saveSession, logEvent, loadEvents, listSessions } from "./session.js";
 import { listPlugins } from "./registry/index.js";
+import { readAgentConfig } from "./registry/plugin-loader.js";
 import { exec } from "node:child_process";
 import os from "node:os";
 import path from "node:path";
@@ -779,12 +780,32 @@ export async function startServer(options = {}) {
         const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
         const resolvedBaseDir = resolvePath(baseDir);
         const defaultName = cfg.name || "OpenBot";
+        // 1. Resolve agent folder
+        let agentFolder = null;
+        if (name === defaultName || name === "default") {
+            agentFolder = resolvedBaseDir;
+        }
+        else {
+            agentFolder = await resolveAgentFolder(name, resolvedBaseDir);
+        }
+        // 2. Check for remote image in AGENT.md if folder exists
+        if (agentFolder) {
+            try {
+                const { image } = await readAgentConfig(agentFolder);
+                if (image && (image.startsWith("http://") || image.startsWith("https://"))) {
+                    return res.redirect(image);
+                }
+            }
+            catch {
+                // ignore
+            }
+        }
         const extensions = [".png", ".jpg", ".jpeg", ".svg", ".webp", ".gif"];
         const fileNames = ["avatar", "icon", "image", "logo"];
         const searchDirs = [
             (name === defaultName || name === "default")
                 ? path.join(resolvedBaseDir, "assets")
-                : path.join(resolvedBaseDir, "agents", name, "assets"),
+                : (agentFolder ? path.join(agentFolder, "assets") : path.join(resolvedBaseDir, "agents", name, "assets")),
             path.join(process.cwd(), "server", "src", "agents", name, "assets"),
             path.join(process.cwd(), "server", "src", "assets", "agents", name),
             path.join(process.cwd(), "server", "src", "agents", "assets"),
@@ -793,7 +814,8 @@ export async function startServer(options = {}) {
         for (const dir of searchDirs) {
             for (const fileName of fileNames) {
                 for (const ext of extensions) {
-                    const baseName = (dir.endsWith("assets") && !dir.includes(name)) ? name : fileName;
+                    const isAgentSpecificDir = dir.includes(name) || (agentFolder && dir.includes(agentFolder));
+                    const baseName = (dir.endsWith("assets") && !isAgentSpecificDir) ? name : fileName;
                     const p = path.join(dir, `${baseName}${ext}`);
                     try {
                         await fs.access(p);
@@ -868,6 +890,7 @@ export async function startServer(options = {}) {
         console.log(`OpenBot server listening at http://localhost:${PORT}`);
         console.log(`  - Chat endpoint: POST /api/chat`);
         console.log(`  - REST endpoints: /api/config, /api/sessions, /api/agents`);
+        console.log(`\n🚀 TIP: Use 'openbot up' to run both the server and web dashboard together.`);
         if (options.openaiApiKey)
             console.log("  - Using OpenAI API Key from CLI");
         if (options.anthropicApiKey)

package/package.json

@@ -1,12 +1,10 @@
 {
   "name": "openbot",
-  "version": "0.2.5",
+  "version": "0.2.6",
   "private": false,
   "type": "module",
-  "scripts": {
-    "dev": "tsx watch src/cli.ts server",
-    "build": "tsc",
-    "start": "node dist/cli.js server"
+  "engines": {
+    "node": ">=20.12.0"
   },
   "bin": {
     "openbot": "./dist/cli.js"
@@ -33,5 +31,10 @@
     "@types/node": "^20.10.1",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
+  },
+  "scripts": {
+    "dev": "tsx watch src/cli.ts server",
+    "build": "tsc",
+    "start": "node dist/cli.js server"
   }
-}
+}