openbot 0.2.2 → 0.2.5

package/dist/server.js

@@ -1,28 +1,166 @@
 import "dotenv/config";
 import express from "express";
 import cors from "cors";
+import chokidar from "chokidar";
 import { generateId } from "melony";
 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 { listYamlAgents } from "./registry/index.js";
+import { listPlugins } from "./registry/index.js";
 import { exec } from "node:child_process";
 import os from "node:os";
 import path from "node:path";
 import fs from "node:fs/promises";
 import { randomUUID } from "node:crypto";
+import matter from "gray-matter";
 import { fetchProviderModels, getModelCatalog } from "./model-catalog.js";
 import { DEFAULT_MODEL_BY_PROVIDER, DEFAULT_MODEL_ID } from "./model-defaults.js";
+import { listAutomations, saveAutomations } from "./automations.js";
+import { startAutomationWorker } from "./automation-worker.js";
+import { getMarketplaceRegistry, installMarketplaceAgent, installMarketplacePlugin } from "./marketplace.js";
+import { getVersionStatus } from "./version.js";
 export async function startServer(options = {}) {
     const config = loadConfig();
     const PORT = Number(options.port ?? config.port ?? process.env.PORT ?? 4001);
     const app = express();
-    const orchestrator = await createOpenBot({
+    const createRuntime = () => createOpenBot({
         openaiApiKey: options.openaiApiKey,
         anthropicApiKey: options.anthropicApiKey,
     });
+    let runtime = await createRuntime();
+    let reloadTimer = null;
+    let reloadInProgress = false;
+    let queuedReload = false;
+    const reloadRuntime = async () => {
+        if (reloadInProgress) {
+            queuedReload = true;
+            return;
+        }
+        reloadInProgress = true;
+        try {
+            const nextRuntime = await createRuntime();
+            runtime = nextRuntime;
+            console.log("[hot-reload] Runtime reloaded from ~/.openbot changes");
+        }
+        catch (error) {
+            console.error("[hot-reload] Reload failed; keeping previous runtime", error);
+        }
+        finally {
+            reloadInProgress = false;
+            if (queuedReload) {
+                queuedReload = false;
+                scheduleReload();
+            }
+        }
+    };
+    const scheduleReload = () => {
+        if (reloadTimer)
+            clearTimeout(reloadTimer);
+        reloadTimer = setTimeout(() => {
+            reloadTimer = null;
+            void reloadRuntime();
+        }, 800);
+    };
+    const openBotDir = path.join(os.homedir(), ".openbot");
+    const watcher = chokidar.watch([
+        path.join(openBotDir, "config.json"),
+        path.join(openBotDir, "AGENT.md"),
+        path.join(openBotDir, "agents", "**", "*"),
+        path.join(openBotDir, "plugins", "**", "*"),
+    ], {
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 300,
+            pollInterval: 100,
+        },
+    });
+    watcher
+        .on("add", scheduleReload)
+        .on("change", scheduleReload)
+        .on("unlink", scheduleReload)
+        .on("addDir", scheduleReload)
+        .on("unlinkDir", scheduleReload)
+        .on("error", (error) => {
+        console.error("[hot-reload] Watcher error", error);
+    });
+    const cleanupWatcher = async () => {
+        if (reloadTimer) {
+            clearTimeout(reloadTimer);
+            reloadTimer = null;
+        }
+        await watcher.close();
+    };
+    const runAutomation = async (automation, scheduledAt) => {
+        const sessionId = `automation_${automation.id}`;
+        const runId = `run_auto_${generateId()}`;
+        const state = (await loadSession(sessionId)) ?? {};
+        state.sessionId = sessionId;
+        if (!state.cwd)
+            state.cwd = process.cwd();
+        if (!state.workspaceRoot)
+            state.workspaceRoot = process.cwd();
+        if (!state.title)
+            state.title = `Automation: ${automation.name}`;
+        const content = automation.targetType === "agent" && automation.agentName
+            ? `/${automation.agentName} ${automation.prompt}`
+            : automation.prompt;
+        const iterator = runtime.run({
+            type: "agent:input",
+            data: { content },
+        }, { runId, state });
+        try {
+            console.log(`[automations] Running "${automation.name}" (${automation.id}) at ${scheduledAt.toISOString()}`);
+            for await (const chunk of iterator) {
+                await logEvent(sessionId, runId, chunk);
+            }
+            console.log(`[automations] Completed "${automation.name}" (${automation.id})`);
+        }
+        catch (error) {
+            console.error(`[automations] Run failed for "${automation.name}" (${automation.id})`, error);
+            throw error;
+        }
+        finally {
+            await saveSession(sessionId, state);
+        }
+    };
+    const stopAutomationWorker = startAutomationWorker({
+        listAutomations,
+        runAutomation,
+    });
+    const cleanupBackground = async () => {
+        stopAutomationWorker();
+        await cleanupWatcher();
+    };
+    process.once("SIGINT", () => {
+        void cleanupBackground().finally(() => process.exit(0));
+    });
+    process.once("SIGTERM", () => {
+        void cleanupBackground().finally(() => process.exit(0));
+    });
     app.use(cors());
     app.use(express.json({ limit: "20mb" }));
+    const fileExists = async (targetPath) => fs.access(targetPath).then(() => true).catch(() => false);
+    const toTitleCaseFromSlug = (value) => value
+        .split(/[-_]+/)
+        .filter(Boolean)
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
+        .join(" ") || "Agent";
+    const resolveAgentFolder = async (agentIdOrName, resolvedBaseDir) => {
+        const agentsDir = path.join(resolvedBaseDir, "agents");
+        const directFolder = path.join(agentsDir, agentIdOrName);
+        if (await fileExists(path.join(directFolder, "AGENT.md"))) {
+            return directFolder;
+        }
+        try {
+            const allPlugins = await listPlugins(agentsDir);
+            const match = allPlugins.find((plugin) => plugin.type === "agent"
+                && (path.basename(plugin.folder) === agentIdOrName || plugin.name === agentIdOrName));
+            return match?.folder ?? null;
+        }
+        catch {
+            return null;
+        }
+    };
     const getUploadsDir = () => {
         const cfg = loadConfig();
         const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
@@ -56,6 +194,16 @@ export async function startServer(options = {}) {
             res.json([]);
         }
     });
+    app.get("/api/version", async (_req, res) => {
+        try {
+            const status = await getVersionStatus();
+            res.json(status);
+        }
+        catch (err) {
+            console.error("Failed to check version:", err);
+            res.status(500).json({ error: "Failed to check version" });
+        }
+    });
     app.post("/api/models/preview", async (req, res) => {
         const { provider, apiKey } = req.body;
         if (provider !== "openai" && provider !== "anthropic") {
@@ -83,6 +231,7 @@ export async function startServer(options = {}) {
                 sessions: "GET /api/sessions",
                 agents: "GET /api/agents",
                 prompts: "GET /api/prompts",
+                version: "GET /api/version",
             },
         });
     });
@@ -95,6 +244,83 @@ export async function startServer(options = {}) {
             { label: "What is the weather in Tokyo?", icon: "sun" },
         ]);
     });
+    app.get("/api/automations", async (_req, res) => {
+        const items = await listAutomations();
+        res.json(items);
+    });
+    app.post("/api/automations", async (req, res) => {
+        const { name, prompt, cron, targetType, agentName } = req.body;
+        const normalizedTargetType = targetType === "agent" ? "agent" : "orchestrator";
+        const normalizedAgentName = typeof agentName === "string" ? agentName.trim() : "";
+        if (typeof name !== "string" ||
+            typeof prompt !== "string" ||
+            typeof cron !== "string" ||
+            !name.trim() ||
+            !prompt.trim() ||
+            !cron.trim() ||
+            (normalizedTargetType === "agent" && !normalizedAgentName)) {
+            return res.status(400).json({ error: "Invalid automation payload" });
+        }
+        const now = new Date().toISOString();
+        const next = {
+            id: `auto_${randomUUID()}`,
+            name: name.trim(),
+            prompt: prompt.trim(),
+            cron: cron.trim(),
+            targetType: normalizedTargetType,
+            agentName: normalizedTargetType === "agent" ? normalizedAgentName : undefined,
+            enabled: true,
+            createdAt: now,
+            updatedAt: now,
+        };
+        const current = await listAutomations();
+        await saveAutomations([next, ...current]);
+        res.status(201).json(next);
+    });
+    app.put("/api/automations/:id", async (req, res) => {
+        const { id } = req.params;
+        const { name, prompt, cron, enabled, targetType, agentName } = req.body;
+        const current = await listAutomations();
+        const index = current.findIndex((item) => item.id === id);
+        if (index < 0) {
+            return res.status(404).json({ error: "Automation not found" });
+        }
+        const existing = current[index];
+        const nextTargetType = targetType === "agent"
+            ? "agent"
+            : targetType === "orchestrator"
+                ? "orchestrator"
+                : existing.targetType;
+        const nextAgentName = typeof agentName === "string"
+            ? agentName.trim()
+            : (existing.agentName ?? "");
+        if (nextTargetType === "agent" && !nextAgentName) {
+            return res.status(400).json({ error: "agentName is required when targetType is agent" });
+        }
+        const updated = {
+            ...existing,
+            name: typeof name === "string" ? name.trim() || existing.name : existing.name,
+            prompt: typeof prompt === "string" ? prompt.trim() || existing.prompt : existing.prompt,
+            cron: typeof cron === "string" ? cron.trim() || existing.cron : existing.cron,
+            targetType: nextTargetType,
+            agentName: nextTargetType === "agent" ? nextAgentName : undefined,
+            enabled: typeof enabled === "boolean" ? enabled : existing.enabled,
+            updatedAt: new Date().toISOString(),
+        };
+        current[index] = updated;
+        await saveAutomations(current);
+        res.json(updated);
+    });
+    app.delete("/api/automations/:id", async (req, res) => {
+        const { id } = req.params;
+        const current = await listAutomations();
+        const next = current.filter((item) => item.id !== id);
+        if (next.length === current.length) {
+            return res.status(404).json({ error: "Automation not found" });
+        }
+        await saveAutomations(next);
+        res.json({ success: true });
+    });
     app.post("/api/uploads/image", async (req, res) => {
         const { name, mimeType, dataBase64 } = req.body;
         if (!mimeType || !allowedMimeTypes.has(mimeType)) {
@@ -160,6 +386,8 @@ export async function startServer(options = {}) {
         const cfg = loadConfig();
         res.json({
             configured: isConfigured(),
+            name: cfg.name || "OpenBot",
+            description: cfg.description || "The main orchestrator and system settings",
             model: cfg.model || DEFAULT_MODEL_ID,
             defaultModelId: DEFAULT_MODEL_ID,
             defaultModels: DEFAULT_MODEL_BY_PROVIDER,
@@ -168,10 +396,16 @@ export async function startServer(options = {}) {
         });
     });
     app.post("/api/config", async (req, res) => {
-        const { openai_api_key, anthropic_api_key, model } = req.body;
+        const { openai_api_key, anthropic_api_key, model, name, description, image } = req.body;
         const updates = {};
+        if (name)
+            updates.name = name.trim();
+        if (description)
+            updates.description = description.trim();
         if (model)
             updates.model = model.trim();
+        if (image !== undefined)
+            updates.image = image.trim();
         if (openai_api_key && openai_api_key !== "••••••••••••••••")
             updates.openaiApiKey = openai_api_key.trim();
         if (anthropic_api_key && anthropic_api_key !== "••••••••••••••••")
@@ -194,53 +428,334 @@ export async function startServer(options = {}) {
         const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
         const resolvedBaseDir = resolvePath(baseDir);
         const agentsDir = path.join(resolvedBaseDir, "agents");
+        const defaultName = cfg.name || "OpenBot";
+        const defaultDescription = cfg.description || "The main orchestrator and system settings";
+        const agents = [
+            {
+                id: "default",
+                name: defaultName,
+                description: defaultDescription,
+                folder: resolvedBaseDir,
+                isDefault: true,
+                hasAgentMd: true,
+                image: cfg.image,
+            },
+        ];
         try {
-            const agents = await listYamlAgents(agentsDir);
-            res.json(agents);
+            const allPlugins = await listPlugins(agentsDir);
+            const agentPlugins = allPlugins.filter(p => p.type === "agent");
+            agents.push(...agentPlugins.map((plugin) => {
+                const id = path.basename(plugin.folder);
+                const hasUnnamedDisplayName = /^Unnamed\s+(Plugin|Tool|Agent)$/i.test(plugin.name);
+                return {
+                    ...plugin,
+                    id,
+                    name: hasUnnamedDisplayName ? toTitleCaseFromSlug(id) : plugin.name,
+                };
+            }));
         }
         catch {
-            res.json([]);
+            // ignore
         }
+        res.json(agents);
     });
-    app.get("/api/agents/:name/yaml", async (req, res) => {
-        const { name } = req.params;
+    app.get("/api/plugins", async (_req, res) => {
+        const cfg = loadConfig();
+        const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
+        const resolvedBaseDir = resolvePath(baseDir);
+        const pluginsDir = path.join(resolvedBaseDir, "plugins");
+        try {
+            const allPlugins = await listPlugins(pluginsDir);
+            const toolPlugins = allPlugins.filter((plugin) => plugin.type === "tool");
+            res.json(toolPlugins.map((plugin) => {
+                const id = path.basename(plugin.folder);
+                const hasUnnamedDisplayName = /^Unnamed\s+(Plugin|Tool|Agent)$/i.test(plugin.name);
+                return {
+                    ...plugin,
+                    id,
+                    name: hasUnnamedDisplayName ? toTitleCaseFromSlug(id) : plugin.name,
+                };
+            }));
+        }
+        catch (error) {
+            console.error(error);
+            res.status(500).json({ error: "Failed to list plugins" });
+        }
+    });
+    app.get("/api/registry/plugins", async (_req, res) => {
+        try {
+            const tools = runtime.registry.getTools();
+            res.json(tools.map((t) => ({
+                name: t.name,
+                description: t.description,
+                isBuiltIn: !!t.isBuiltIn,
+            })));
+        }
+        catch (error) {
+            console.error(error);
+            res.status(500).json({ error: "Failed to list registry plugins" });
+        }
+    });
+    app.get("/api/marketplace/agents", async (_req, res) => {
+        try {
+            const registry = await getMarketplaceRegistry();
+            res.json(registry.agents);
+        }
+        catch (error) {
+            console.error(error);
+            res.status(500).json({ error: "Failed to load marketplace agents" });
+        }
+    });
+    app.get("/api/marketplace/plugins", async (_req, res) => {
+        try {
+            const registry = await getMarketplaceRegistry();
+            res.json(registry.plugins);
+        }
+        catch (error) {
+            console.error(error);
+            res.status(500).json({ error: "Failed to load marketplace plugins" });
+        }
+    });
+    app.post("/api/marketplace/install-agent", async (req, res) => {
+        const { id } = req.body;
+        if (typeof id !== "string" || !id.trim()) {
+            return res.status(400).json({ error: "Marketplace agent id is required" });
+        }
+        try {
+            const result = await installMarketplaceAgent(id.trim());
+            res.json({ success: true, installedName: result.installedName, item: result.agent });
+        }
+        catch (error) {
+            console.error(error);
+            res.status(500).json({ error: error instanceof Error ? error.message : "Failed to install agent" });
+        }
+    });
+    app.post("/api/marketplace/install-plugin", async (req, res) => {
+        const { id } = req.body;
+        if (typeof id !== "string" || !id.trim()) {
+            return res.status(400).json({ error: "Marketplace plugin id is required" });
+        }
+        try {
+            const result = await installMarketplacePlugin(id.trim());
+            res.json({ success: true, installedName: result.installedName, item: result.plugin });
+        }
+        catch (error) {
+            console.error(error);
+            res.status(500).json({ error: error instanceof Error ? error.message : "Failed to install plugin" });
+        }
+    });
+    app.get("/api/agents/:agentId/md", async (req, res) => {
+        const { agentId } = req.params;
         const cfg = loadConfig();
         const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
         const resolvedBaseDir = resolvePath(baseDir);
-        const yamlPath = path.join(resolvedBaseDir, "agents", name, "agent.yaml");
+        const defaultName = cfg.name || "OpenBot";
+        let mdPath;
+        if (agentId === defaultName || agentId === "default") {
+            mdPath = path.join(resolvedBaseDir, "AGENT.md");
+        }
+        else {
+            const pluginFolder = await resolveAgentFolder(agentId, resolvedBaseDir);
+            if (!pluginFolder) {
+                return res.status(404).send("");
+            }
+            mdPath = path.join(pluginFolder, "AGENT.md");
+        }
         try {
-            const content = await fs.readFile(yamlPath, "utf-8");
-            res.send(content);
+            const content = await fs.readFile(mdPath, "utf-8");
+            const { content: body } = matter(content);
+            res.send(body.trim());
         }
         catch {
-            res.status(404).send("Agent not found or has no agent.yaml");
+            res.status(404).send("");
         }
     });
-    app.put("/api/agents/:name/yaml", async (req, res) => {
-        const { name } = req.params;
-        const { yaml } = req.body;
-        if (!yaml || typeof yaml !== "string") {
-            return res.status(400).json({ error: "YAML content is required" });
+    app.put("/api/agents/:agentId/md", async (req, res) => {
+        const { agentId } = req.params;
+        const { md } = req.body;
+        const cfg = loadConfig();
+        const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
+        const resolvedBaseDir = resolvePath(baseDir);
+        const defaultName = cfg.name || "OpenBot";
+        let mdPath;
+        let pluginDir;
+        if (agentId === defaultName || agentId === "default") {
+            pluginDir = resolvedBaseDir;
+            mdPath = path.join(resolvedBaseDir, "AGENT.md");
         }
+        else {
+            const pluginFolder = await resolveAgentFolder(agentId, resolvedBaseDir);
+            if (!pluginFolder) {
+                return res.status(404).json({ error: "Agent not found" });
+            }
+            pluginDir = pluginFolder;
+            mdPath = path.join(pluginDir, "AGENT.md");
+        }
+        try {
+            await fs.mkdir(pluginDir, { recursive: true });
+            let frontmatter = {};
+            try {
+                const currentContent = await fs.readFile(mdPath, "utf-8");
+                const parsed = matter(currentContent);
+                frontmatter = parsed.data || {};
+            }
+            catch {
+                // No current AGENT.md, starting with empty frontmatter or defaults
+            }
+            const consolidated = matter.stringify(md, frontmatter);
+            await fs.writeFile(mdPath, consolidated, "utf-8");
+            res.json({ success: true });
+        }
+        catch (err) {
+            console.error(err);
+            res.status(500).json({ error: "Failed to write AGENT.md" });
+        }
+    });
+    app.get("/api/agents/:agentId/config", async (req, res) => {
+        const { agentId } = req.params;
         const cfg = loadConfig();
         const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
         const resolvedBaseDir = resolvePath(baseDir);
-        const agentDir = path.join(resolvedBaseDir, "agents", name);
-        const yamlPath = path.join(agentDir, "agent.yaml");
+        const defaultName = cfg.name || "OpenBot";
+        let mdPath;
+        if (agentId === defaultName || agentId === "default") {
+            mdPath = path.join(resolvedBaseDir, "AGENT.md");
+        }
+        else {
+            const pluginFolder = await resolveAgentFolder(agentId, resolvedBaseDir);
+            if (!pluginFolder) {
+                return res.status(404).json({ error: "Agent not found or invalid format" });
+            }
+            mdPath = path.join(pluginFolder, "AGENT.md");
+        }
         try {
-            await fs.mkdir(agentDir, { recursive: true });
-            await fs.writeFile(yamlPath, yaml, "utf-8");
-            // Optionally, hot-reload openBotAgent if needed here.
-            // But OpenBot runtime loads agents at startup or dynamically per request?
-            // createOpenBot builds the Melony App. Since createOpenBot is called at startup:
-            // openBotAgent = await createOpenBot(...) happens once.
-            // Restarting server is required unless we hot-reload. We can just leave it as is 
-            // and instruct the user to restart, or implement a simple hot reload. Let's stick to simple file write first.
+            const content = await fs.readFile(mdPath, "utf-8");
+            const { data: parsed, content: body } = matter(content);
+            if (!parsed || typeof parsed !== "object") {
+                return res.status(400).json({ error: "Invalid AGENT.md frontmatter" });
+            }
+            res.json({
+                name: typeof parsed.name === "string" ? parsed.name : (agentId === defaultName || agentId === "default" ? defaultName : ""),
+                description: typeof parsed.description === "string" ? parsed.description : (agentId === defaultName || agentId === "default" ? cfg.description || "" : ""),
+                model: typeof parsed.model === "string" ? parsed.model : (agentId === defaultName || agentId === "default" ? cfg.model : undefined),
+                plugins: Array.isArray(parsed.plugins) ? parsed.plugins : [],
+                subscribe: Array.isArray(parsed.subscribe)
+                    ? parsed.subscribe.filter((item) => typeof item === "string")
+                    : [],
+            });
+        }
+        catch {
+            if (agentId === defaultName || agentId === "default") {
+                // Fallback for default agent if AGENT.md is missing or unreadable
+                return res.json({
+                    name: defaultName,
+                    description: cfg.description || "",
+                    model: cfg.model,
+                    plugins: [],
+                    systemPrompt: "",
+                    subscribe: [],
+                });
+            }
+            res.status(404).json({ error: "Agent not found or invalid format" });
+        }
+    });
+    app.put("/api/agents/:agentId/config", async (req, res) => {
+        const { agentId } = req.params;
+        const body = req.body;
+        if (typeof body.name !== "string" ||
+            typeof body.description !== "string" ||
+            !Array.isArray(body.plugins)) {
+            return res.status(400).json({ error: "Invalid agent config payload" });
+        }
+        const normalizedPlugins = [];
+        for (const plugin of body.plugins) {
+            if (typeof plugin === "string") {
+                const normalized = plugin.trim();
+                if (normalized)
+                    normalizedPlugins.push(normalized);
+                continue;
+            }
+            if (!plugin || typeof plugin !== "object" || typeof plugin.name !== "string") {
+                continue;
+            }
+            const normalizedName = plugin.name.trim();
+            if (!normalizedName)
+                continue;
+            if (typeof plugin.config === "undefined") {
+                normalizedPlugins.push({ name: normalizedName });
+            }
+            else {
+                normalizedPlugins.push({ name: normalizedName, config: plugin.config });
+            }
+        }
+        const normalizedName = body.name.trim();
+        const normalizedDescription = body.description.trim();
+        if (!normalizedName || !normalizedDescription) {
+            return res.status(400).json({ error: "name and description are required" });
+        }
+        const cfg = loadConfig();
+        const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
+        const resolvedBaseDir = resolvePath(baseDir);
+        const defaultName = cfg.name || "OpenBot";
+        let pluginDir;
+        let mdPath;
+        if (agentId === defaultName || agentId === "default") {
+            pluginDir = resolvedBaseDir;
+            mdPath = path.join(resolvedBaseDir, "AGENT.md");
+        }
+        else {
+            const pluginFolder = await resolveAgentFolder(agentId, resolvedBaseDir);
+            if (!pluginFolder) {
+                return res.status(404).json({ error: "Agent not found" });
+            }
+            pluginDir = pluginFolder;
+            mdPath = path.join(pluginDir, "AGENT.md");
+        }
+        // Read current content to preserve the body (instructions)
+        let currentBody = "";
+        try {
+            const currentContent = await fs.readFile(mdPath, "utf-8");
+            const parsed = matter(currentContent);
+            currentBody = parsed.content;
+        }
+        catch {
+            // No current AGENT.md, starting with empty body or defaults
+        }
+        // Prepare frontmatter
+        const frontmatter = {
+            name: normalizedName,
+            description: normalizedDescription,
+            plugins: normalizedPlugins,
+        };
+        if (typeof body.model === "string" && body.model.trim()) {
+            frontmatter.model = body.model.trim();
+        }
+        if (Array.isArray(body.subscribe) && body.subscribe.length > 0) {
+            const normalizedSubscribe = body.subscribe
+                .filter((item) => typeof item === "string")
+                .map((item) => item.trim())
+                .filter(Boolean);
+            if (normalizedSubscribe.length > 0) {
+                frontmatter.subscribe = normalizedSubscribe;
+            }
+        }
+        try {
+            await fs.mkdir(pluginDir, { recursive: true });
+            const consolidated = matter.stringify(currentBody, frontmatter);
+            await fs.writeFile(mdPath, consolidated, "utf-8");
+            if (agentId === defaultName || agentId === "default") {
+                // For the default agent, sync changes back to config.json
+                saveConfig({
+                    name: normalizedName,
+                    description: normalizedDescription,
+                    model: (typeof body.model === "string" && body.model.trim()) ? body.model.trim() : undefined,
+                });
+            }
             res.json({ success: true });
         }
         catch (err) {
             console.error(err);
-            res.status(500).json({ error: "Failed to write agent.yaml" });
+            res.status(500).json({ error: "Failed to write AGENT.md" });
         }
     });
     app.post("/api/actions/open-folder", async (req, res) => {
@@ -263,10 +778,13 @@ export async function startServer(options = {}) {
         const cfg = loadConfig();
         const baseDir = cfg.baseDir || DEFAULT_BASE_DIR;
         const resolvedBaseDir = resolvePath(baseDir);
+        const defaultName = cfg.name || "OpenBot";
         const extensions = [".png", ".jpg", ".jpeg", ".svg", ".webp", ".gif"];
         const fileNames = ["avatar", "icon", "image", "logo"];
         const searchDirs = [
-            path.join(resolvedBaseDir, "agents", name, "assets"),
+            (name === defaultName || name === "default")
+                ? path.join(resolvedBaseDir, "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"),
@@ -313,12 +831,12 @@ export async function startServer(options = {}) {
             state.cwd = process.cwd();
         if (!state.workspaceRoot)
             state.workspaceRoot = process.cwd();
-        const iterator = orchestrator.run(body.event, {
+        const iterator = runtime.run(body.event, {
             runId,
             state,
         });
         const stopStreaming = () => {
-            iterator.return?.({ done: true, value: undefined });
+            void iterator.return?.();
         };
         res.on("close", stopStreaming);
         try {