openbot 0.1.22 → 0.1.24

package/dist/registry/plugin-loader.js

@@ -0,0 +1,100 @@
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+import { execSync } from "node:child_process";
+/**
+ * Ensure a plugin is ready to run by installing dependencies and building if necessary.
+ */
+export async function ensurePluginReady(pluginDir) {
+    try {
+        const pkgPath = path.join(pluginDir, "package.json");
+        const hasPackageJson = await fs.access(pkgPath).then(() => true).catch(() => false);
+        if (!hasPackageJson)
+            return;
+        const pkg = JSON.parse(await fs.readFile(pkgPath, "utf-8"));
+        const nodeModulesPath = path.join(pluginDir, "node_modules");
+        const hasNodeModules = await fs.access(nodeModulesPath).then(() => true).catch(() => false);
+        // 1. Install dependencies if node_modules is missing
+        if (!hasNodeModules) {
+            console.log(`[plugins] Installing dependencies for ${path.basename(pluginDir)}...`);
+            execSync("npm install --production", { cwd: pluginDir, stdio: "inherit" });
+        }
+        // 2. Run build if dist is missing but build script exists
+        const distPath = path.join(pluginDir, "dist");
+        const hasDist = await fs.access(distPath).then(() => true).catch(() => false);
+        if (!hasDist && pkg.scripts?.build) {
+            console.log(`[plugins] Building ${path.basename(pluginDir)}...`);
+            execSync("npm run build", { cwd: pluginDir, stdio: "inherit" });
+        }
+    }
+    catch (err) {
+        console.error(`[plugins] Failed to prepare plugin in ${pluginDir}:`, err);
+    }
+}
+/**
+ * Dynamically load plugins from a directory.
+ * Scans each subdirectory for an index.js (or index.ts if running via tsx).
+ */
+export async function loadPluginsFromDir(dir) {
+    const plugins = [];
+    try {
+        await fs.access(dir);
+    }
+    catch {
+        // Directory doesn't exist
+        return plugins;
+    }
+    try {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            if (entry.name.startsWith(".") || entry.name.startsWith("_"))
+                continue;
+            const pluginDir = path.join(dir, entry.name);
+            // Ensure plugin is ready (dependencies, build)
+            await ensurePluginReady(pluginDir);
+            // Try to find index.js or index.ts, prioritizing dist/index.js for pre-built bundles
+            let indexPath;
+            const possibleIndices = ["dist/index.js", "index.js", "index.ts"];
+            for (const file of possibleIndices) {
+                try {
+                    const fullPath = path.join(pluginDir, file);
+                    await fs.access(fullPath);
+                    indexPath = fullPath;
+                    break;
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (!indexPath) {
+                console.warn(`[plugins] No index.js or index.ts found in ${pluginDir}`);
+                continue;
+            }
+            try {
+                // Use pathToFileURL for compatibility with import() on all OSs
+                const moduleUrl = pathToFileURL(indexPath).href;
+                const module = await import(moduleUrl);
+                // The plugin can be exported as 'plugin', 'default', or 'entry'
+                const entryData = module.plugin || module.default || module.entry;
+                if (entryData && typeof entryData.factory === "function") {
+                    plugins.push({
+                        ...entryData,
+                        name: entryData.name || entry.name, // Fallback to folder name
+                    });
+                }
+                else {
+                    console.warn(`[plugins] "${entry.name}" does not export a valid plugin entry (missing factory)`);
+                }
+            }
+            catch (err) {
+                console.error(`[plugins] Failed to load plugin "${entry.name}":`, err);
+            }
+        }
+    }
+    catch (err) {
+        console.warn(`[plugins] Error reading directory ${dir}:`, err);
+    }
+    return plugins;
+}

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

@@ -2,7 +2,29 @@ import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import yaml from "js-yaml";
 import { llmPlugin } from "../plugins/llm/index.js";
+import { PluginRegistry } from "./plugin-registry.js";
 import { createModel } from "../models.js";
+import { loadPluginsFromDir } from "./plugin-loader.js";
+import { resolvePath } from "../config.js";
+/**
+ * Recursively resolve tilde paths in a configuration object.
+ */
+function resolveConfigPaths(config) {
+    if (typeof config === "string") {
+        return resolvePath(config);
+    }
+    if (Array.isArray(config)) {
+        return config.map(resolveConfigPaths);
+    }
+    if (config !== null && typeof config === "object") {
+        const resolved = {};
+        for (const [key, value] of Object.entries(config)) {
+            resolved[key] = resolveConfigPaths(value);
+        }
+        return resolved;
+    }
+    return config;
+}
 /**
  * Discover and load YAML-defined agents from a directory.
  *
@@ -32,6 +54,7 @@ export async function discoverYamlAgents(agentsDir, pluginRegistry, defaultModel
             if (entry.name.startsWith(".") || entry.name.startsWith("_"))
                 continue;
             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);
@@ -40,15 +63,32 @@ export async function discoverYamlAgents(agentsDir, pluginRegistry, defaultModel
                     console.warn(`[agents] "${entry.name}/agent.yaml": missing required fields (name, description, plugins, systemPrompt) — skipping`);
                     continue;
                 }
-                // Use agent-specific model if defined, otherwise use default
                 const agentModel = config.model
                     ? createModel({ ...options, model: config.model })
                     : defaultModel;
-                const plugin = composeAgentFromYaml(config, pluginRegistry, agentModel);
+                // 1. Load local plugins from agents/<name>/plugins/
+                const localPluginsDir = path.join(agentDir, "plugins");
+                const localPlugins = await loadPluginsFromDir(localPluginsDir);
+                // 2. Create a scoped registry for this agent: global + local
+                const scopedRegistry = new PluginRegistry();
+                // Add all global plugins
+                for (const p of pluginRegistry.getAll()) {
+                    scopedRegistry.register(p);
+                }
+                // Add local plugins (overwriting globals if names conflict)
+                for (const p of localPlugins) {
+                    scopedRegistry.register(p);
+                }
+                const { plugin, toolDefinitions } = composeAgentFromYaml(config, scopedRegistry, agentModel);
                 agents.push({
                     name: config.name,
                     description: config.description,
                     plugin,
+                    capabilities: Object.fromEntries(Object.entries(toolDefinitions).map(([name, def]) => [
+                        name,
+                        def.description,
+                    ])),
+                    subscribe: config.subscribe,
                 });
                 console.log(`[agents] Loaded: ${config.name} — ${config.description}${config.model ? ` (model: ${config.model})` : ""}`);
             }
@@ -70,22 +110,24 @@ export async function discoverYamlAgents(agentsDir, pluginRegistry, defaultModel
  * and wires them with an agent-scoped LLM plugin.
  */
 function composeAgentFromYaml(config, pluginRegistry, model) {
-    return (builder) => {
-        const allToolDefinitions = {};
-        for (const pluginName of config.plugins) {
-            const entry = pluginRegistry.get(pluginName);
-            if (!entry) {
-                console.warn(`[agents] "${config.name}": plugin "${pluginName}" not found in registry — skipping`);
-                continue;
-            }
-            // Register the plugin's event handlers
-            builder.use(entry.factory());
-            // Register UI plugin if available
-            if (entry.uiFactory) {
-                builder.use(entry.uiFactory());
-            }
-            // Collect tool definitions for the LLM
-            Object.assign(allToolDefinitions, entry.toolDefinitions);
+    const allToolDefinitions = {};
+    const pluginFactories = [];
+    for (const pluginItem of config.plugins) {
+        const isString = typeof pluginItem === "string";
+        const pluginName = isString ? pluginItem : pluginItem.name;
+        const pluginConfig = isString ? {} : (pluginItem.config || {});
+        const resolvedConfig = resolveConfigPaths(pluginConfig);
+        const entry = pluginRegistry.get(pluginName);
+        if (!entry) {
+            console.warn(`[agents] "${config.name}": plugin "${pluginName}" not found in registry — skipping`);
+            continue;
+        }
+        pluginFactories.push({ factory: entry.factory, config: resolvedConfig });
+        Object.assign(allToolDefinitions, entry.toolDefinitions);
+    }
+    const plugin = (builder) => {
+        for (const { factory, config: resolvedConfig } of pluginFactories) {
+            builder.use(factory({ ...resolvedConfig, model }));
         }
         // Wire up the LLM with agent-scoped event channels
         builder.use(llmPlugin({
@@ -97,4 +139,5 @@ function composeAgentFromYaml(config, pluginRegistry, model) {
             completionEventType: `agent:${config.name}:output`,
         }));
     };
+    return { plugin, toolDefinitions: allToolDefinitions };
 }

package/dist/server.js

@@ -70,8 +70,6 @@ export async function startServer(options = {}) {
         const runId = body.runId ?? `run_${generateId()}`;
         const state = (await loadSession(sessionId)) ?? {};
         state.sessionId = sessionId;
-        // Log the incoming event
-        await logEvent(sessionId, runId, body.event);
         const iterator = runtime.run(body.event, {
             runId,
             state,

package/dist/session.js

@@ -124,10 +124,15 @@ export async function listSessions() {
                         const sessionPath = path.join(itemPath, subItem);
                         const statePath = path.join(sessionPath, "state.json");
                         if (fs.existsSync(statePath)) {
-                            sessions.push({
-                                id: subItem,
-                                mtime: fs.statSync(statePath).birthtime, // sort by creation time
-                            });
+                            const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+                            // Only include sessions with messages or a title
+                            if ((state.messages && state.messages.length > 0) || state.title) {
+                                sessions.push({
+                                    id: subItem,
+                                    mtime: fs.statSync(statePath).birthtime, // sort by creation time
+                                    title: state.title ?? undefined,
+                                });
+                            }
                         }
                     }
                 }
@@ -135,10 +140,15 @@ export async function listSessions() {
                     // It's a legacy session folder in root
                     const statePath = path.join(itemPath, "state.json");
                     if (fs.existsSync(statePath)) {
-                        sessions.push({
-                            id: item,
-                            mtime: fs.statSync(statePath).birthtime, // sort by creation time
-                        });
+                        const state = JSON.parse(fs.readFileSync(statePath, "utf-8"));
+                        // Only include sessions with messages or a title
+                        if ((state.messages && state.messages.length > 0) || state.title) {
+                            sessions.push({
+                                id: item,
+                                title: state.title ?? undefined,
+                                mtime: fs.statSync(statePath).birthtime, // sort by creation time
+                            });
+                        }
                     }
                 }
             }

package/dist/ui/layout.js

@@ -11,9 +11,10 @@ const tabs = {
 };
 export const layoutUI = async ({ tab, sessionId }) => {
     const sessions = await listSessions();
+    const content = typeof tabs[tab] === "function" ? await tabs[tab]() : tabs[tab];
     return ui.row({ height: "full" }, [
         sidebarUI({ sessions, sessionId }),
-        tabs[tab]
+        content
     ]);
 };
 export const sidebarOnlyUI = async ({ sessionId }) => {
@@ -21,5 +22,5 @@ export const sidebarOnlyUI = async ({ sessionId }) => {
     return sidebarUI({ sessions, sessionId });
 };
 export const tabOnlyUI = async ({ tab }) => {
-    return tabs[tab];
+    return typeof tabs[tab] === "function" ? await tabs[tab]() : tabs[tab];
 };

package/dist/ui/settings.js

@@ -1,44 +1,75 @@
 import { ui } from "@melony/ui-kit";
-export const settingsUI = 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.row({ align: "center", gap: "md" }, [
-                ui.box({ flex: 1 }, [
-                    ui.node("label", { value: "Provider" }),
-                    ui.text("OpenAI (GPT-4o)", { size: "sm", color: "mutedForeground" }),
+import { loadConfig } from "../config.js";
+export const settingsUI = async () => {
+    const config = loadConfig();
+    const hasOpenAIKey = !!config.openaiApiKey;
+    const hasAnthropicKey = !!config.anthropicApiKey;
+    return ui.form({
+        onSubmitAction: {
+            type: "action:updateSettings",
+            data: {}
+        }
+    }, [
+        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.button({ label: "Change", variant: "outline", size: "sm" })
-            ]),
-        ]),
-        ui.col({ gap: "md" }, [
-            ui.heading("API Keys", 4),
-            ui.col({ gap: "sm" }, [
-                ui.node("label", { value: "OpenAI API Key" }),
-                ui.row({ gap: "sm" }, [
-                    ui.input("openai_api_key", undefined, {
-                        placeholder: "sk-...",
-                        inputType: "password",
-                        defaultValue: "••••••••••••••••",
-                        width: "full"
-                    }),
-                    ui.button({ label: "Save", size: "sm" })
+                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({ 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.divider(),
+                ui.row({ justify: "end" }, [
+                    ui.button({
+                        label: "Save Settings",
+                        type: "submit",
+                        variant: "primary"
+                    })
                 ])
             ])
-        ]),
-        ui.col({ gap: "md" }, [
-            ui.heading("Theme", 4),
-            ui.themeToggle(),
         ])
-    ])
-]);
+    ]);
+};