openbot 0.1.20 → 0.1.23

package/README.md

@@ -13,7 +13,7 @@ npm i -g openbot
 To start your assistant's server, just run:
 
 ```bash
-openbot-server
+openbot server
 ```
 
 OpenBot will start listening for you at `http://localhost:4001`.

package/dist/agents/browser-agent.js

@@ -0,0 +1,31 @@
+import { llmPlugin } from "../plugins/llm/index.js";
+import { browserPlugin, browserToolDefinitions, } from "../plugins/browser/index.js";
+const DEFAULT_SYSTEM_PROMPT = `You are a Browser Agent.
+Your job is to help the user browse the web, extract information, and perform actions.
+
+Tools:
+- browser_act: Give a natural language instruction to interact with the page (e.g. "click the login button").
+- browser_observe: See what actions are available on the current page.
+- browser_extract: Pull structured data from the page.
+- browser_state_update: Get a fresh screenshot and URL.
+
+Always describe what you see and what you are doing.`;
+/**
+ * High-level Browser Agent plugin for Melony.
+ * Composes the low-level browserPlugin with an llmPlugin.
+ */
+export const browserAgent = (options) => (builder) => {
+    const { model, systemPrompt = DEFAULT_SYSTEM_PROMPT } = options;
+    builder
+        .use(browserPlugin({ ...options, model }))
+        .use(llmPlugin({
+        model,
+        system: systemPrompt,
+        toolDefinitions: browserToolDefinitions,
+        promptInputType: "agent:browser:input",
+        actionResultInputType: "agent:browser:result",
+        completionEventType: "agent:browser:output",
+    }));
+    // NOTE: Bridge-back to the manager is handled generically by open-bot.ts.
+    // No per-agent boilerplate needed.
+};

package/dist/agents/os-agent.js

@@ -0,0 +1,31 @@
+import { llmPlugin } from "../plugins/llm/index.js";
+import { shellPlugin, shellToolDefinitions } from "../plugins/shell/index.js";
+import { shellUIPlugin } from "../plugins/shell/ui.js";
+import { fileSystemPlugin, fileSystemToolDefinitions } from "../plugins/file-system/index.js";
+import { fileSystemUIPlugin } from "../plugins/file-system/ui.js";
+const DEFAULT_SYSTEM_PROMPT = `You are an OS Agent with access to the shell and file system.
+Your job is to help the user with file operations and command execution.
+You can read, write, list, and delete files, as well as execute shell commands.
+Always be careful with destructive operations.
+When you are done with the task, summarize what you did.`;
+export const osAgent = (options) => (builder) => {
+    const { model, cwd = process.cwd(), systemPrompt = DEFAULT_SYSTEM_PROMPT } = options;
+    builder
+        .use(shellPlugin({ cwd }))
+        .use(shellUIPlugin())
+        .use(fileSystemPlugin({ baseDir: "/" }))
+        .use(fileSystemUIPlugin())
+        .use(llmPlugin({
+        model,
+        system: systemPrompt,
+        toolDefinitions: {
+            ...shellToolDefinitions,
+            ...fileSystemToolDefinitions,
+        },
+        promptInputType: "agent:os:input",
+        actionResultInputType: "agent:os:result",
+        completionEventType: "agent:os:output",
+    }));
+    // NOTE: Bridge-back to the manager is handled generically by open-bot.ts.
+    // No per-agent boilerplate needed.
+};

package/dist/cli.js

@@ -2,11 +2,12 @@
 import { Command } from "commander";
 import * as readline from "node:readline/promises";
 import { saveConfig } from "./config.js";
+import { startServer } from "./server.js";
 const program = new Command();
 program
     .name("openbot")
     .description("OpenBot CLI - Secure and easy configuration")
-    .version("0.1.20");
+    .version("0.1.23");
 program
     .command("configure")
     .description("Configure OpenBot model and settings")
@@ -46,15 +47,24 @@ program
     console.log("------------------------------------------");
     if (provider === "openai") {
         console.log("To start the server with your OpenAI key, use:");
-        console.log(`\n  openbot-server --openai-api-key YOUR_OPENAI_KEY\n`);
+        console.log(`\n  openbot server --openai-api-key YOUR_OPENAI_KEY\n`);
     }
     else {
         console.log("To start the server with your Anthropic key, use:");
-        console.log(`\n  openbot-server --anthropic-api-key YOUR_ANTHROPIC_KEY\n`);
+        console.log(`\n  openbot server --anthropic-api-key YOUR_ANTHROPIC_KEY\n`);
     }
     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("------------------------------------------");
     rl.close();
 });
+program
+    .command("server")
+    .description("Start the OpenBot server")
+    .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) => {
+    await startServer(options);
+});
 program.parse();

package/dist/handlers/init.js

@@ -1,4 +1,4 @@
-import { layoutUI } from "../ui/layout.js";
+import { sidebarOnlyUI, tabOnlyUI } from "../ui/layout.js";
 /**
  * Initial application layout handler
  */
@@ -10,8 +10,20 @@ export async function* initHandler(event, { state }) {
     if (!state.workspaceRoot) {
         state.workspaceRoot = process.cwd();
     }
+    const tab = event.data?.tab || "chat";
+    // For init, return both sidebar and content
     yield {
         type: "ui",
-        data: await layoutUI({ tab: event.data?.tab || "chat", sessionId: state.sessionId })
+        meta: {
+            type: "sidebar",
+        },
+        data: await sidebarOnlyUI({ sessionId: state.sessionId })
+    };
+    yield {
+        type: "ui",
+        meta: {
+            type: "content",
+        },
+        data: await tabOnlyUI({ tab })
     };
 }

package/dist/handlers/session-change.js

@@ -0,0 +1,21 @@
+import { sidebarOnlyUI, tabOnlyUI } from "../ui/layout.js";
+/**
+ * Session change handler
+ */
+export async function* sessionChangeHandler(event, { state }) {
+    const tab = event.data?.tab || "chat";
+    yield {
+        type: "ui",
+        meta: {
+            type: "sidebar",
+        },
+        data: await sidebarOnlyUI({ sessionId: state.sessionId })
+    };
+    yield {
+        type: "ui",
+        meta: {
+            type: "content",
+        },
+        data: await tabOnlyUI({ tab })
+    };
+}

package/dist/handlers/tab-change.js

@@ -0,0 +1,14 @@
+import { tabOnlyUI } from "../ui/layout.js";
+/**
+ * Tab change handler
+ */
+export async function* tabChangeHandler(event, { state }) {
+    const tab = event.data?.tab || "chat";
+    yield {
+        type: "ui",
+        meta: {
+            type: "content",
+        },
+        data: await tabOnlyUI({ tab })
+    };
+}

package/dist/models.js

@@ -0,0 +1,53 @@
+import { openai } from "@ai-sdk/openai";
+import { anthropic } from "@ai-sdk/anthropic";
+import { loadConfig } from "./config.js";
+/**
+ * Parse model string to extract provider and model ID
+ * Supports formats: "provider:model", "provider/model", or just "model" (defaults to openai)
+ */
+export function parseModelString(modelString) {
+    // Check for provider:model format
+    if (modelString.includes(":")) {
+        const [provider, modelId] = modelString.split(":");
+        if (provider === "openai" || provider === "anthropic") {
+            return { provider: provider, modelId };
+        }
+    }
+    // Check for provider/model format
+    if (modelString.includes("/")) {
+        const [provider, modelId] = modelString.split("/");
+        if (provider === "openai" || provider === "anthropic") {
+            return { provider: provider, modelId };
+        }
+    }
+    // Auto-detect provider based on model name
+    if (modelString.startsWith("claude") || modelString.startsWith("claude-")) {
+        return { provider: "anthropic", modelId: modelString };
+    }
+    // Default to OpenAI
+    return { provider: "openai", modelId: modelString };
+}
+export function createModel(options) {
+    const config = loadConfig();
+    const openaiKey = options?.openaiApiKey || config.openaiApiKey || process.env.OPENAI_API_KEY;
+    const anthropicKey = options?.anthropicApiKey || config.anthropicApiKey || process.env.ANTHROPIC_API_KEY;
+    if (openaiKey) {
+        process.env.OPENAI_API_KEY = openaiKey;
+    }
+    if (anthropicKey) {
+        process.env.ANTHROPIC_API_KEY = anthropicKey;
+    }
+    const { provider, modelId } = parseModelString(options?.model || config.model || "gpt-4o-mini");
+    if (provider === "anthropic") {
+        if (!anthropicKey) {
+            console.warn("Warning: Anthropic model selected but ANTHROPIC_API_KEY is not set");
+        }
+        return anthropic(modelId);
+    }
+    else {
+        if (!openaiKey) {
+            console.warn("Warning: OpenAI model selected but OPENAI_API_KEY is not set");
+        }
+        return openai(modelId);
+    }
+}

package/dist/open-bot.js

@@ -0,0 +1,166 @@
+import { melony } from "melony";
+import { osAgent } from "./agents/os-agent.js";
+import { browserAgent } from "./agents/browser-agent.js";
+import { browserUIPlugin } from "./plugins/browser/ui.js";
+import { brainPlugin, brainToolDefinitions, createBrainPromptBuilder } from "./plugins/brain/index.js";
+import { brainUIPlugin } from "./plugins/brain/ui.js";
+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 { loadConfig, resolvePath, DEFAULT_BASE_DIR } from "./config.js";
+import { createModel } from "./models.js";
+import path from "node:path";
+import { z } from "zod";
+// Plugin imports for the registry
+import { shellPlugin, shellToolDefinitions } from "./plugins/shell/index.js";
+import { shellUIPlugin } from "./plugins/shell/ui.js";
+import { fileSystemPlugin, fileSystemToolDefinitions } from "./plugins/file-system/index.js";
+import { fileSystemUIPlugin } from "./plugins/file-system/ui.js";
+import { browserPlugin, browserToolDefinitions } from "./plugins/browser/index.js";
+// Registry
+import { PluginRegistry, AgentRegistry, discoverYamlAgents } from "./registry/index.js";
+/**
+ * Create the OpenBot manager agent.
+ *
+ * Architecture:
+ *  1. Built-in plugins are registered in the Plugin Registry so YAML agents can reference them by name.
+ *  2. Built-in agents + YAML agents discovered from ~/.openbot/agents/ are registered in the Agent Registry.
+ *  3. The manager LLM gets a dynamically-built `delegateTask` tool listing all registered agents.
+ *  4. A generic delegation handler + bridge-back wiring replaces per-agent boilerplate.
+ */
+export async function createOpenBot(options) {
+    const config = loadConfig();
+    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();
+    pluginRegistry.register({
+        name: "shell",
+        description: "Execute shell commands",
+        toolDefinitions: shellToolDefinitions,
+        factory: () => shellPlugin({ cwd: process.cwd() }),
+        uiFactory: () => shellUIPlugin(),
+    });
+    pluginRegistry.register({
+        name: "file-system",
+        description: "Read, write, list, and delete files",
+        toolDefinitions: fileSystemToolDefinitions,
+        factory: () => fileSystemPlugin({ baseDir: "/" }),
+        uiFactory: () => fileSystemUIPlugin(),
+    });
+    pluginRegistry.register({
+        name: "browser",
+        description: "Browse the web and interact with pages",
+        toolDefinitions: browserToolDefinitions,
+        factory: () => browserPlugin({
+            headless: true,
+            userDataDir,
+            channel: "chrome",
+            model: model,
+        }),
+        uiFactory: () => browserUIPlugin(),
+    });
+    // ─── Agent Registry ──────────────────────────────────────────────
+    // Register built-in agents, then discover YAML agents from ~/.openbot/agents/.
+    const agentRegistry = new AgentRegistry();
+    agentRegistry.register({
+        name: "os",
+        description: "Handles shell commands and file system operations",
+        plugin: osAgent({ model: model }),
+    });
+    agentRegistry.register({
+        name: "browser",
+        description: "Browses the web, extracts data, and interacts with pages",
+        plugin: browserAgent({
+            model: model,
+            headless: true,
+            userDataDir,
+            channel: "chrome",
+        }),
+    });
+    // Discover community / user agents from ~/.openbot/agents/
+    const yamlAgents = await discoverYamlAgents(path.join(resolvedBaseDir, "agents"), pluginRegistry, model, options);
+    for (const agent of yamlAgents) {
+        agentRegistry.register(agent);
+    }
+    // ─── Compose the Melony App ──────────────────────────────────────
+    const allAgents = agentRegistry.getAll();
+    const agentNames = agentRegistry.getNames();
+    const app = melony();
+    // 1. Register all agent plugins
+    for (const agent of allAgents) {
+        app.use(agent.plugin);
+    }
+    // 2. Register global plugins (brain, UI, etc.)
+    const buildBrainPrompt = createBrainPromptBuilder(baseDir);
+    app
+        .use(browserUIPlugin())
+        .use(brainPlugin({
+        baseDir: resolvedBaseDir,
+        allowSoulModification: false,
+    }))
+        .use(brainUIPlugin());
+    // 3. Build dynamic delegation tool from the agent registry
+    const agentDescriptions = allAgents
+        .map((a) => `- ${a.name}: ${a.description}`)
+        .join("\n");
+    app.use(llmPlugin({
+        model: model,
+        system: async (context) => {
+            const [brainPrompt] = await Promise.all([
+                buildBrainPrompt(context),
+            ]);
+            return `${brainPrompt}`;
+        },
+        toolDefinitions: {
+            ...brainToolDefinitions,
+            delegateTask: {
+                description: `Delegate a task to a specialized agent.\n\nAvailable agents:\n${agentDescriptions}`,
+                inputSchema: z.object({
+                    agent: z.enum(agentNames).describe("The specialized agent to use"),
+                    task: z.string().describe("The task description"),
+                }),
+            },
+        },
+    }));
+    // 4. Generic delegation handler — works for any registered agent
+    app.on("action:delegateTask", async function* (event, { state }) {
+        const { agent, task, toolCallId } = event.data;
+        const s = state;
+        if (!s.pendingAgentTasks)
+            s.pendingAgentTasks = {};
+        s.pendingAgentTasks[agent] = { toolCallId };
+        yield {
+            type: `agent:${agent}:input`,
+            data: { content: task },
+        };
+    });
+    // 5. Generic bridge-back handlers — auto-wired for every registered agent
+    for (const agent of allAgents) {
+        app.on(`agent:${agent.name}:output`, async function* (event, { state }) {
+            const s = state;
+            const pending = s.pendingAgentTasks?.[agent.name];
+            if (pending) {
+                delete s.pendingAgentTasks[agent.name];
+                yield {
+                    type: "action:taskResult",
+                    data: {
+                        action: "delegateTask",
+                        toolCallId: pending.toolCallId,
+                        result: event.data.content,
+                    },
+                };
+            }
+        });
+    }
+    // 6. Init handlers
+    app
+        .on("init", initHandler)
+        .on("sessionChange", sessionChangeHandler)
+        .on("tabChange", tabChangeHandler);
+    return app;
+}

package/dist/plugins/agent/index.js

@@ -0,0 +1,81 @@
+import { streamText } from "ai";
+import { ui } from "@melony/ui-kit";
+/**
+ * Builds a simple history summary from recent messages.
+ * Keeps the last N messages as simple role/content pairs.
+ */
+function getRecentHistory(messages, maxMessages) {
+    return messages.slice(-maxMessages);
+}
+/**
+ * AI SDK Plugin for Melony.
+ * Automatically handles text events and routes them through an LLM using Vercel AI SDK.
+ * It can also automatically trigger events based on tool calls.
+ */
+export const agentPlugin = (options) => (builder) => {
+    const { model, system, toolDefinitions = {}, actionEventPrefix = "action:", promptInputType = "user:text", actionResultInputType = "action:result", completionEventType } = options;
+    async function* routeToLLM(newMessage, context) {
+        const state = context.state;
+        if (!state.messages) {
+            state.messages = [];
+        }
+        // Add new message to history
+        state.messages.push(newMessage);
+        // Evaluate dynamic system prompt if it's a function
+        const systemPrompt = typeof system === "function" ? await system(context) : system;
+        const result = streamText({
+            model,
+            system: systemPrompt,
+            messages: getRecentHistory(state.messages, 20).map(m => m.role === "system" ? { role: "user", content: `System: ${m.content}` } : m),
+            tools: toolDefinitions,
+        });
+        let assistantText = "";
+        for await (const delta of result.textStream) {
+            assistantText += delta;
+            yield {
+                type: "assistant:text-delta",
+                data: { delta },
+            };
+        }
+        // Wait for tool calls to complete
+        const toolCalls = await result.toolCalls;
+        // Store assistant response as simple text
+        if (assistantText) {
+            state.messages.push({
+                role: "assistant",
+                content: assistantText,
+            });
+            if (completionEventType) {
+                yield {
+                    type: completionEventType,
+                    data: { content: assistantText },
+                };
+            }
+        }
+        const usage = await result.usage;
+        yield ui.event(ui.status(`Usage: ${usage.totalTokens} tokens`, "info"));
+        // Emit tool call events
+        for (const call of toolCalls) {
+            yield {
+                type: `${actionEventPrefix}${call.toolName}`,
+                data: {
+                    ...call.input,
+                    toolCallId: call.toolCallId,
+                },
+            };
+        }
+    }
+    // Handle user text input
+    builder.on(promptInputType, async function* (event, context) {
+        const content = event.data.content;
+        yield* routeToLLM({ role: "user", content }, context);
+    });
+    // Feed action results back to the LLM as user messages (with a System prefix)
+    // We use "user" role instead of "system" to avoid errors with providers like Anthropic
+    // that don't support multiple system messages or system messages after the first turn.
+    builder.on(actionResultInputType, async function* (event, context) {
+        const { action, result } = event.data;
+        const summary = typeof result === "string" ? result : JSON.stringify(result);
+        yield* routeToLLM({ role: "user", content: `System: Action "${action}" completed: ${summary}` }, context);
+    });
+};

package/dist/plugins/brain/identity.js

@@ -0,0 +1,76 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+// --- Defaults ---
+const DEFAULT_SOUL = `# Soul
+
+## Core Values
+- Be helpful, honest, and harmless
+- Respect user privacy and data
+- Learn and improve continuously
+- Be transparent about capabilities and limitations
+
+## Ethical Guidelines
+- Never assist with harmful or illegal activities
+- Protect sensitive information
+- Acknowledge uncertainty when unsure
+- Prioritize user well-being
+`;
+const DEFAULT_IDENTITY = `# Identity
+
+I am OpenBot, a self-evolving AI assistant built on the OpenBot framework.
+
+## Personality
+- Friendly and approachable
+- Technically competent
+- Eager to learn and adapt
+
+## Capabilities
+- Shell command execution
+- File system operations
+- Skill-based task execution
+- Self-modification and learning
+`;
+// --- Factory ---
+export function createIdentityModule(baseDir) {
+    const soulPath = path.join(baseDir, "SOUL.md");
+    const identityPath = path.join(baseDir, "IDENTITY.md");
+    return {
+        async initialize() {
+            try {
+                await fs.access(soulPath);
+            }
+            catch {
+                await fs.writeFile(soulPath, DEFAULT_SOUL, "utf-8");
+            }
+            try {
+                await fs.access(identityPath);
+            }
+            catch {
+                await fs.writeFile(identityPath, DEFAULT_IDENTITY, "utf-8");
+            }
+        },
+        async getSoul() {
+            try {
+                return (await fs.readFile(soulPath, "utf-8")).trim();
+            }
+            catch {
+                return "";
+            }
+        },
+        async getIdentity() {
+            try {
+                return (await fs.readFile(identityPath, "utf-8")).trim();
+            }
+            catch {
+                return "";
+            }
+        },
+        async updateIdentity(content) {
+            await fs.writeFile(identityPath, content, "utf-8");
+        },
+        async readFile(file) {
+            const filePath = file === "SOUL.md" ? soulPath : identityPath;
+            return await fs.readFile(filePath, "utf-8");
+        },
+    };
+}