openbot 0.2.13 → 0.3.0

package/dist/services/storage.js

@@ -1,19 +1,13 @@
-import { DEFAULT_AGENTS_DIR, DEFAULT_BASE_DIR, DEFAULT_CHANNELS_DIR, DEFAULT_PLUGINS_DIR, loadConfig, resolvePath, VARIABLES_FILE, } from '../app/config.js';
+import { DEFAULT_PLUGINS_DIR, DEFAULT_AGENTS_DIR, DEFAULT_BASE_DIR, DEFAULT_CHANNELS_DIR, loadConfig, resolvePath, VARIABLES_FILE, } from '../app/config.js';
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import crypto from 'node:crypto';
 import matter from 'gray-matter';
-import { getSystemAgentDetails } from '../agents/system.js';
+import { aiSdkPlugin } from '../plugins/ai-sdk/index.js';
+import { AI_SDK_SYSTEM_PROMPT } from '../plugins/ai-sdk/system-prompt.js';
+import { listBuiltInPlugins, parsePluginModule } from '../registry/plugins.js';
+import { processService } from '../harness/process.js';
 import { pathToFileURL } from 'node:url';
-const mapNameToPlugin = (name, description, kind = 'tool', image) => ({
-    id: name,
-    name,
-    description,
-    kind,
-    image,
-    createdAt: new Date(),
-    updatedAt: new Date(),
-});
 const resolveBaseDir = () => {
     const config = loadConfig();
     return resolvePath(config.baseDir || DEFAULT_BASE_DIR);
@@ -32,15 +26,6 @@ const tryReadSvgDataUrl = async (filePath) => {
         return null;
     }
 };
-/**
- * Auto-discovers an entity SVG avatar and returns it as a data URL.
- *
- * Search order:
- * 1) <entity>/assets/avatar.svg|icon.svg|image.svg|logo.svg
- * 2) <entity>/avatar.svg|icon.svg|image.svg|logo.svg
- * 3) first *.svg in <entity>/assets
- * 4) first *.svg in <entity>
- */
 const resolveEntityImageDataUrl = async (entityDir) => {
     const preferredDirs = [path.join(entityDir, 'assets'), entityDir];
     for (const dir of preferredDirs) {
@@ -61,7 +46,7 @@ const resolveEntityImageDataUrl = async (entityDir) => {
                 return dataUrl;
         }
         catch {
-            // ignore missing/unreadable folders
+            // ignore
         }
     }
     return undefined;
@@ -70,6 +55,59 @@ const getConversationDir = (channelId, threadId) => {
     const base = resolvePath(resolveBaseDir() + '/' + DEFAULT_CHANNELS_DIR + '/' + channelId);
     return threadId ? `${base}/threads/${threadId}` : base;
 };
+/** Built-in orchestrator agent id. Not creatable as a normal disk agent. */
+const SYSTEM_AGENT_ID = 'system';
+const SYSTEM_DEFAULT_PLUGINS = [
+    { id: 'ai-sdk', config: { model: 'openai/gpt-5.4-nano' } },
+    { id: 'storage-tools' },
+    // { id: 'mcp' },
+    { id: 'shell' },
+    { id: 'delegation' },
+    // { id: 'ui' },
+    { id: 'approval' },
+];
+function getSystemAgentDetails(overrides) {
+    const defaults = {
+        id: SYSTEM_AGENT_ID,
+        name: 'OpenBot',
+        image: undefined,
+        description: 'First-party orchestration agent for OpenBot. Coordinates other agents via handoff and delegation.',
+        instructions: AI_SDK_SYSTEM_PROMPT,
+        plugins: SYSTEM_DEFAULT_PLUGINS.map((ref) => ref.id),
+        pluginRefs: SYSTEM_DEFAULT_PLUGINS,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+    };
+    if (!overrides)
+        return defaults;
+    const refs = overrides.pluginRefs && overrides.pluginRefs.length > 0
+        ? overrides.pluginRefs
+        : defaults.pluginRefs;
+    return {
+        ...defaults,
+        ...overrides,
+        id: SYSTEM_AGENT_ID,
+        image: overrides.image || defaults.image,
+        plugins: refs.map((ref) => ref.id),
+        pluginRefs: refs,
+        updatedAt: new Date(),
+    };
+}
+// Suppress unused warning until system agent customization re-uses aiSdkPlugin metadata.
+void aiSdkPlugin;
+const RESERVED_DISK_AGENT_IDS = new Set([SYSTEM_AGENT_ID]);
+const assertValidDiskAgentId = (agentId) => {
+    if (!agentId || typeof agentId !== 'string') {
+        throw new Error('agentId is required');
+    }
+    if (RESERVED_DISK_AGENT_IDS.has(agentId)) {
+        throw new Error(`Agent id "${agentId}" is reserved`);
+    }
+    if (!/^[a-zA-Z0-9_-]+$/.test(agentId)) {
+        throw new Error('agentId must contain only letters, digits, underscores, and hyphens');
+    }
+};
+const getAgentsRootDir = () => path.join(resolveBaseDir(), DEFAULT_AGENTS_DIR);
 const getLastReadFilePath = () => path.join(resolvePath(resolveBaseDir() + '/' + DEFAULT_CHANNELS_DIR), '_meta', 'last-read.json');
 const THREAD_TITLE_MAX_LENGTH = 80;
 const buildThreadTitleFromEvent = (event) => {
@@ -104,25 +142,67 @@ const toVariablesRecord = (raw) => {
     if (!raw || typeof raw !== 'object') {
         return {};
     }
-    // Current format: { version: number, variables: StoredVariable[] }
     if ('variables' in raw && Array.isArray(raw.variables)) {
         const entries = raw.variables
             .filter((variable) => typeof variable?.key === 'string')
             .map((variable) => [variable.key, String(variable.value ?? '')]);
         return Object.fromEntries(entries);
     }
-    // Legacy format: { [key: string]: string }
     return Object.fromEntries(Object.entries(raw).map(([key, value]) => [
         key,
         String(value ?? ''),
     ]));
 };
-const listBuiltInPlugins = async () => {
-    return [
-        mapNameToPlugin('storage', 'Built-in storage plugin'),
-        mapNameToPlugin('ai-sdk', 'Built-in AI SDK plugin', 'runtime'),
-        mapNameToPlugin('delegation', 'Built-in delegation plugin'),
-    ];
+const listBuiltInPluginDescriptors = async () => {
+    return listBuiltInPlugins().map((plugin) => ({
+        id: plugin.id,
+        name: plugin.name,
+        description: plugin.description,
+        builtIn: true,
+        image: plugin.image,
+        defaultInstructions: plugin.defaultInstructions,
+        configSchema: plugin.configSchema,
+        createdAt: new Date(),
+        updatedAt: new Date(),
+    }));
+};
+/**
+ * Walk `plugins/` and yield candidate plugin ids (npm names). Includes scoped
+ * packages by recursing one level into directories starting with `@`.
+ */
+const listInstalledPluginIds = async (pluginsDir) => {
+    const out = [];
+    let topEntries;
+    try {
+        topEntries = await fs.readdir(pluginsDir, { withFileTypes: true });
+    }
+    catch {
+        return out;
+    }
+    for (const entry of topEntries) {
+        if (entry.name.startsWith('.'))
+            continue;
+        if (!entry.isDirectory() && !entry.isSymbolicLink())
+            continue;
+        if (entry.name.startsWith('@')) {
+            try {
+                const inner = await fs.readdir(path.join(pluginsDir, entry.name), { withFileTypes: true });
+                for (const sub of inner) {
+                    if (sub.name.startsWith('.'))
+                        continue;
+                    if (sub.isDirectory() || sub.isSymbolicLink()) {
+                        out.push(`${entry.name}/${sub.name}`);
+                    }
+                }
+            }
+            catch {
+                // ignore
+            }
+            continue;
+        }
+        out.push(entry.name);
+    }
+    return out;
 };
 const listPluginsFromDisk = async () => {
     const pluginsDir = resolvePath(resolveBaseDir() + '/' + DEFAULT_PLUGINS_DIR);
@@ -132,17 +212,57 @@ const listPluginsFromDisk = async () => {
     catch {
         await fs.mkdir(pluginsDir, { recursive: true });
     }
-    const plugins = (await fs.readdir(pluginsDir, { withFileTypes: true }))
-        .filter((entry) => !entry.name.startsWith('.') && (entry.isDirectory() || entry.isSymbolicLink()))
-        .map(async (entry) => {
-        // get dist/index module and find inside module.plugin.description
-        const module = await import(pathToFileURL(`${pluginsDir}/${entry.name}/dist/index.js`).href);
-        const pluginDir = path.join(pluginsDir, entry.name);
-        const image = await resolveEntityImageDataUrl(pluginDir);
-        return mapNameToPlugin(module.plugin.name || entry.name, module.plugin.description || '', module.plugin.kind || 'tool', image);
-    });
-    return Promise.all(plugins);
+    const ids = await listInstalledPluginIds(pluginsDir);
+    const descriptors = await Promise.all(ids.map(async (id) => {
+        try {
+            const pluginDir = path.join(pluginsDir, id);
+            const distPath = path.join(pluginDir, 'dist', 'index.js');
+            const module = await import(pathToFileURL(distPath).href);
+            const parsed = parsePluginModule(module);
+            if (!parsed)
+                return null;
+            const image = await resolveEntityImageDataUrl(pluginDir);
+            return {
+                id,
+                name: parsed.name || id,
+                description: parsed.description || '',
+                builtIn: false,
+                image: parsed.image || image,
+                defaultInstructions: parsed.defaultInstructions,
+                configSchema: parsed.configSchema,
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+        }
+        catch (error) {
+            console.warn(`[storage] Failed to load plugin ${id}:`, error);
+            return null;
+        }
+    }));
+    return descriptors.filter((d) => d !== null);
+};
+const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+/**
+ * Parse the `plugins:` array from AGENT.md frontmatter. Each entry must have an
+ * `id`; `config` is optional. Strings are accepted as a shorthand for `{ id }`.
+ */
+const parsePluginRefs = (raw) => {
+    if (!Array.isArray(raw))
+        return [];
+    const refs = [];
+    for (const entry of raw) {
+        if (typeof entry === 'string' && entry.trim()) {
+            refs.push({ id: entry.trim() });
+            continue;
+        }
+        if (isRecord(entry) && typeof entry.id === 'string' && entry.id.trim()) {
+            const config = isRecord(entry.config) ? entry.config : undefined;
+            refs.push({ id: entry.id.trim(), ...(config ? { config } : {}) });
+        }
+    }
+    return refs;
 };
+const serializePluginRefs = (refs) => refs.map((ref) => (ref.config ? { id: ref.id, config: ref.config } : { id: ref.id }));
 export const storageService = {
     getLastReadByChannel: async () => {
         return readJsonFile(getLastReadFilePath(), {});
@@ -174,7 +294,7 @@ export const storageService = {
                 cwd = typeof state.cwd === 'string' ? state.cwd : undefined;
             }
             catch {
-                // Ignore if state.json is missing or invalid
+                // ignore
             }
             const channel = {
                 id: name,
@@ -194,7 +314,6 @@ export const storageService = {
                 channel.hasUnseenMessages = false;
             }
             try {
-                // Fetch up to 5 most recent threads for the sidebar
                 const allThreads = await storageService.getThreads({ channelId: name });
                 channel.recentThreads = allThreads
                     .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())
@@ -220,7 +339,8 @@ export const storageService = {
             throw new Error(`Channel "${normalizedChannelId}" already exists`);
         }
         catch (error) {
-            if (error.code !== 'ENOENT') {
+            const code = error?.code;
+            if (code !== 'ENOENT') {
                 throw error;
             }
         }
@@ -238,12 +358,10 @@ export const storageService = {
     createThread: async ({ channelId, threadId, threadTitle, spec, initialState, }) => {
         const normalizedChannelId = channelId.trim();
         const normalizedThreadId = threadId.trim();
-        if (!normalizedChannelId) {
+        if (!normalizedChannelId)
             throw new Error('channelId is required');
-        }
-        if (!normalizedThreadId) {
+        if (!normalizedThreadId)
             throw new Error('threadId is required');
-        }
         const threadDir = getConversationDir(normalizedChannelId, normalizedThreadId);
         const specPath = `${threadDir}/SPEC.md`;
         const statePath = `${threadDir}/state.json`;
@@ -252,7 +370,8 @@ export const storageService = {
             throw new Error(`Thread "${normalizedThreadId}" already exists in channel "${normalizedChannelId}"`);
         }
         catch (error) {
-            if (error.code !== 'ENOENT') {
+            const code = error?.code;
+            if (code !== 'ENOENT') {
                 throw error;
             }
         }
@@ -288,7 +407,7 @@ export const storageService = {
                 }
             }
             catch (error) {
-                if (error.code !== 'ENOENT') {
+                if (error?.code !== 'ENOENT') {
                     console.error(`Failed to read thread state for channel ${channelId} thread ${name}`, error);
                 }
             }
@@ -311,7 +430,7 @@ export const storageService = {
             spec = await fs.readFile(specPath, 'utf-8');
         }
         catch (error) {
-            if (error.code !== 'ENOENT') {
+            if (error?.code !== 'ENOENT') {
                 console.error(`Failed to read thread spec for channel ${channelId} thread ${threadId}`, error);
             }
         }
@@ -321,11 +440,11 @@ export const storageService = {
             state = JSON.parse(stateContent);
         }
         catch (error) {
-            if (error.code !== 'ENOENT') {
+            if (error?.code !== 'ENOENT') {
                 console.error(`Failed to read thread state for channel ${channelId} thread ${threadId}`, error);
             }
         }
-        const generatedName = typeof state.generatedName === 'string'
+        const generatedName = isRecord(state) && typeof state.generatedName === 'string'
             ? state.generatedName.trim()
             : '';
         return {
@@ -345,7 +464,7 @@ export const storageService = {
             spec = await fs.readFile(specPath, 'utf-8');
         }
         catch (error) {
-            if (error.code !== 'ENOENT') {
+            if (error?.code !== 'ENOENT') {
                 console.error(`Failed to read spec file for channel ${channelId}`, error);
             }
         }
@@ -355,16 +474,17 @@ export const storageService = {
             state = JSON.parse(stateContent);
         }
         catch (error) {
-            if (error.code !== 'ENOENT') {
+            if (error?.code !== 'ENOENT') {
                 console.error(`Failed to read state file for channel ${channelId}`, error);
             }
         }
+        const cwd = isRecord(state) && typeof state.cwd === 'string' ? state.cwd : undefined;
         const details = {
             id: channelId,
             name: channelId,
             spec,
             state,
-            cwd: typeof state.cwd === 'string' ? state.cwd : undefined,
+            cwd,
         };
         details.threads = await storageService.getThreads({ channelId });
         return details;
@@ -373,15 +493,12 @@ export const storageService = {
         const channelDir = getConversationDir(channelId);
         const statePath = `${channelDir}/state.json`;
         try {
-            // 1. Fetch current details to get the existing state
             const currentDetails = await storageService.getChannelDetails({ channelId });
             const currentState = currentDetails.state || {};
-            // 2. Perform a shallow merge (patch)
             const newState = {
                 ...currentState,
                 ...patch,
             };
-            // 3. Write back the merged state
             await fs.mkdir(channelDir, { recursive: true });
             await fs.writeFile(statePath, JSON.stringify(newState, null, 2));
         }
@@ -394,15 +511,12 @@ export const storageService = {
         const threadDir = getConversationDir(channelId, threadId);
         const statePath = `${threadDir}/state.json`;
         try {
-            // 1. Fetch current details to get the existing state
             const currentDetails = await storageService.getThreadDetails({ channelId, threadId });
             const currentState = currentDetails.state || {};
-            // 2. Perform a shallow merge (patch)
             const newState = {
                 ...currentState,
                 ...patch,
             };
-            // 3. Write back the merged state
             await fs.mkdir(threadDir, { recursive: true });
             await fs.writeFile(statePath, JSON.stringify(newState, null, 2));
         }
@@ -452,7 +566,7 @@ export const storageService = {
                     name: details.name || id,
                     description: details.description || '',
                     image: details.image,
-                    runtime: details.runtime,
+                    plugins: details.plugins,
                     createdAt: details.createdAt,
                     updatedAt: details.updatedAt,
                 };
@@ -462,18 +576,19 @@ export const storageService = {
                     id,
                     name: id,
                     description: '',
+                    plugins: [],
                     createdAt: new Date(),
                     updatedAt: new Date(),
                 };
             }
         }));
-        const system = await storageService.getAgentDetails({ agentId: 'system' });
+        const system = await storageService.getAgentDetails({ agentId: SYSTEM_AGENT_ID });
         const builtInSystemAgent = {
             id: system.id,
             name: system.name,
             description: system.description || '',
             image: system.image,
-            runtime: system.runtime,
+            plugins: system.plugins,
             createdAt: system.createdAt,
             updatedAt: system.updatedAt,
         };
@@ -486,11 +601,11 @@ export const storageService = {
         return Array.from(deduped.values());
     },
     getPlugins: async () => {
-        const [builtInPlugins, diskPlugins] = await Promise.all([
-            listBuiltInPlugins(),
+        const [builtIn, fromDisk] = await Promise.all([
+            listBuiltInPluginDescriptors(),
             listPluginsFromDisk(),
         ]);
-        const merged = [...builtInPlugins, ...diskPlugins];
+        const merged = [...builtIn, ...fromDisk];
         const deduped = new Map();
         for (const plugin of merged) {
             if (!deduped.has(plugin.id)) {
@@ -508,26 +623,30 @@ export const storageService = {
             const agentMd = await fs.readFile(agentMdPath, 'utf-8');
             const { data, content: instructions } = matter(agentMd);
             const discoveredImage = await resolveEntityImageDataUrl(agentDir);
+            const stats = await fs.stat(agentMdPath);
+            const pluginRefs = parsePluginRefs(data.plugins);
             diskDetails = {
                 id: agentId,
-                name: data.name || agentId,
+                name: typeof data.name === 'string' ? data.name : agentId,
                 instructions: instructions.trim(),
-                runtime: data.runtime,
-                plugins: data.plugins || [],
-                description: data.description || '',
+                plugins: pluginRefs.map((ref) => ref.id),
+                pluginRefs,
+                description: typeof data.description === 'string' ? data.description : '',
                 image: discoveredImage || undefined,
-                createdAt: new Date(),
-                updatedAt: new Date(),
+                createdAt: stats.birthtime,
+                updatedAt: stats.mtime,
             };
         }
         catch (error) {
-            if (agentId !== 'system') {
+            if (agentId !== SYSTEM_AGENT_ID) {
                 const err = new Error(`Agent "${agentId}" does not exist.`);
                 err.code = 'AGENT_NOT_FOUND';
                 throw err;
             }
+            // swallow: system agent has on-disk overrides optional
+            void error;
         }
-        if (agentId === 'system') {
+        if (agentId === SYSTEM_AGENT_ID) {
             return getSystemAgentDetails(diskDetails);
         }
         if (!diskDetails) {
@@ -537,6 +656,103 @@ export const storageService = {
         }
         return diskDetails;
     },
+    createAgent: async ({ agentId, name, description = '', instructions, plugins, }) => {
+        assertValidDiskAgentId(agentId);
+        const agentDir = resolvePath(path.join(getAgentsRootDir(), agentId));
+        const agentMdPath = path.join(agentDir, 'AGENT.md');
+        try {
+            await fs.access(agentMdPath);
+            throw new Error(`Agent "${agentId}" already exists`);
+        }
+        catch (error) {
+            const code = error?.code;
+            if (code === 'ENOENT') {
+                // proceed
+            }
+            else if (error instanceof Error && error.message.includes('already exists')) {
+                throw error;
+            }
+            else {
+                throw error;
+            }
+        }
+        await fs.mkdir(agentDir, { recursive: true });
+        const data = {
+            name,
+            description,
+            plugins: serializePluginRefs(plugins),
+        };
+        const body = matter.stringify(`${instructions.trim()}\n`, data);
+        await fs.writeFile(agentMdPath, body, 'utf-8');
+    },
+    updateAgent: async ({ agentId, name, description, instructions, plugins, }) => {
+        assertValidDiskAgentId(agentId);
+        const agentDir = resolvePath(path.join(getAgentsRootDir(), agentId));
+        const agentMdPath = path.join(agentDir, 'AGENT.md');
+        let raw;
+        try {
+            raw = await fs.readFile(agentMdPath, 'utf-8');
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT') {
+                const err = new Error(`Agent "${agentId}" does not exist.`);
+                err.code = 'AGENT_NOT_FOUND';
+                throw err;
+            }
+            throw error;
+        }
+        const parsed = matter(raw);
+        const nextData = { ...parsed.data };
+        if (name !== undefined)
+            nextData.name = name;
+        if (description !== undefined)
+            nextData.description = description;
+        if (plugins !== undefined)
+            nextData.plugins = serializePluginRefs(plugins);
+        const nextContent = instructions !== undefined ? instructions : parsed.content;
+        const body = matter.stringify(`${String(nextContent).trim()}\n`, nextData);
+        await fs.writeFile(agentMdPath, body, 'utf-8');
+    },
+    deleteAgent: async ({ agentId }) => {
+        assertValidDiskAgentId(agentId);
+        const agentDir = resolvePath(path.join(getAgentsRootDir(), agentId));
+        const agentMdPath = path.join(agentDir, 'AGENT.md');
+        const packageJsonPath = path.join(agentDir, 'package.json');
+        try {
+            await fs.access(agentDir);
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT') {
+                const err = new Error(`Agent "${agentId}" does not exist.`);
+                err.code = 'AGENT_NOT_FOUND';
+                throw err;
+            }
+            throw error;
+        }
+        let hasPackage = false;
+        let hasAgentMd = false;
+        try {
+            await fs.access(packageJsonPath);
+            hasPackage = true;
+        }
+        catch {
+            // ignore
+        }
+        try {
+            await fs.access(agentMdPath);
+            hasAgentMd = true;
+        }
+        catch {
+            // ignore
+        }
+        if (hasPackage && !hasAgentMd) {
+            throw new Error(`Cannot delete TypeScript agent package "${agentId}" through this action; remove the folder manually.`);
+        }
+        if (!hasAgentMd) {
+            throw new Error(`Agent "${agentId}" has no AGENT.md and cannot be deleted through this action.`);
+        }
+        await fs.rm(agentDir, { recursive: true, force: true });
+    },
     getEvents: async ({ channelId, threadId, }) => {
         try {
             const threadDir = getConversationDir(channelId, threadId);
@@ -554,22 +770,18 @@ export const storageService = {
                 }
                 return event;
             });
-            // If we are at the channel level (no threadId), check which events have threads
             if (!threadId) {
                 const threadsDir = resolvePath(resolveBaseDir() + '/' + DEFAULT_CHANNELS_DIR + '/' + channelId + '/threads');
                 try {
                     const threadDirs = await fs.readdir(threadsDir);
                     const threadSet = new Set(threadDirs);
                     return events.map((event) => {
-                        // Check if this event has a threadId associated with it
-                        // The frontend provides the threadId, and it matches the directory name on disk
-                        const threadId = event.id;
-                        // If an explicit threadId exists and has a directory, use it
-                        if (threadId && threadSet.has(threadId)) {
+                        const eventThreadId = event.id;
+                        if (eventThreadId && threadSet.has(eventThreadId)) {
                             return {
                                 ...event,
                                 meta: {
-                                    ...event?.meta,
+                                    ...(event.meta || {}),
                                     hasThread: true,
                                 },
                             };
@@ -578,14 +790,13 @@ export const storageService = {
                     });
                 }
                 catch {
-                    // No threads folder or other error, just return events as is
                     return events;
                 }
             }
             return events;
         }
         catch (error) {
-            if (error.code !== 'ENOENT') {
+            if (error?.code !== 'ENOENT') {
                 console.error(`Failed to get events for channel ${channelId} thread ${threadId}`, error);
             }
             return [];
@@ -599,7 +810,7 @@ export const storageService = {
                     await fs.access(threadDir);
                 }
                 catch (error) {
-                    if (error.code === 'ENOENT') {
+                    if (error?.code === 'ENOENT') {
                         const threadTitle = buildThreadTitleFromEvent(event);
                         await storageService.createThread({
                             channelId,
@@ -615,7 +826,6 @@ export const storageService = {
             else {
                 await fs.mkdir(threadDir, { recursive: true });
             }
-            // Ensure the event has a unique ID
             if (!event.id) {
                 event.id = crypto.randomUUID();
             }
@@ -629,15 +839,70 @@ export const storageService = {
     getVariables: async () => {
         const variablesFilePath = resolvePath(resolveBaseDir() + '/' + VARIABLES_FILE);
         const raw = await readJsonFile(variablesFilePath, {});
-        if (raw && typeof raw === 'object' && 'variables' in raw && Array.isArray(raw.variables)) {
-            const entries = raw.variables
+        if (raw &&
+            typeof raw === 'object' &&
+            'variables' in raw &&
+            Array.isArray(raw.variables)) {
+            const entries = (raw.variables)
                 .filter((v) => typeof v?.key === 'string')
                 .map((v) => [v.key, { value: String(v.value ?? ''), secret: !!v.secret }]);
             return Object.fromEntries(entries);
         }
-        // Legacy or simple format
         return toVariablesRecord(raw);
     },
+    createVariable: async ({ key, value, secret = false, }) => {
+        const variablesFilePath = resolvePath(resolveBaseDir() + '/' + VARIABLES_FILE);
+        const raw = await readJsonFile(variablesFilePath, { version: 1, variables: [] });
+        let variables = [];
+        if (raw &&
+            typeof raw === 'object' &&
+            'variables' in raw &&
+            Array.isArray(raw.variables)) {
+            variables = raw.variables;
+        }
+        else {
+            variables = Object.entries(toVariablesRecord(raw)).map(([k, v]) => ({
+                key: k,
+                value: v,
+                secret: false,
+            }));
+        }
+        const existingIndex = variables.findIndex((v) => v.key === key);
+        if (existingIndex !== -1) {
+            variables[existingIndex] = { key, value, secret };
+        }
+        else {
+            variables.push({ key, value, secret });
+        }
+        await fs.mkdir(path.dirname(variablesFilePath), { recursive: true });
+        await fs.writeFile(variablesFilePath, JSON.stringify({ version: 1, variables }, null, 2), 'utf-8');
+        processService.syncWorkspaceVariablesToProcessEnv();
+    },
+    deleteVariable: async ({ key }) => {
+        const variablesFilePath = resolvePath(resolveBaseDir() + '/' + VARIABLES_FILE);
+        const raw = await readJsonFile(variablesFilePath, { version: 1, variables: [] });
+        let variables = [];
+        if (raw &&
+            typeof raw === 'object' &&
+            'variables' in raw &&
+            Array.isArray(raw.variables)) {
+            variables = raw.variables;
+        }
+        else {
+            variables = Object.entries(toVariablesRecord(raw)).map(([k, v]) => ({
+                key: k,
+                value: v,
+                secret: false,
+            }));
+        }
+        const newVariables = variables.filter((v) => v.key !== key);
+        if (newVariables.length === variables.length) {
+            return;
+        }
+        await fs.mkdir(path.dirname(variablesFilePath), { recursive: true });
+        await fs.writeFile(variablesFilePath, JSON.stringify({ version: 1, variables: newVariables }, null, 2), 'utf-8');
+        processService.syncWorkspaceVariablesToProcessEnv();
+    },
     listFiles: async ({ channelId, path: subPath = '', }) => {
         const details = await storageService.getChannelDetails({ channelId });
         const baseCwd = details.cwd;
@@ -646,19 +911,18 @@ export const storageService = {
         }
         const resolvedBase = path.resolve(baseCwd);
         const targetDir = path.resolve(resolvedBase, subPath);
-        // Security check: ensure target is within baseCwd
         if (!targetDir.startsWith(resolvedBase)) {
             throw new Error('Access denied: directory escape');
         }
         const entries = await fs.readdir(targetDir, { withFileTypes: true });
         return entries
-            .filter((e) => !e.name.startsWith('.')) // Hide hidden files by default for MVP
+            .filter((e) => !e.name.startsWith('.'))
             .map((e) => ({
             name: e.name,
             isDirectory: e.isDirectory(),
         }));
     },
-    readFile: async ({ channelId, path: filePath }) => {
+    readFile: async ({ channelId, path: filePath, }) => {
         const details = await storageService.getChannelDetails({ channelId });
         const baseCwd = details.cwd;
         if (!baseCwd) {
@@ -666,7 +930,6 @@ export const storageService = {
         }
         const resolvedBase = path.resolve(baseCwd);
         const targetFile = path.resolve(resolvedBase, filePath);
-        // Security check: ensure target is within baseCwd
         if (!targetFile.startsWith(resolvedBase)) {
             throw new Error('Access denied: directory escape');
         }
@@ -686,7 +949,7 @@ export const storageService = {
             throw error;
         }
         let channelDetails;
-        if (channelId && channelId !== 'general') {
+        if (channelId) {
             try {
                 channelDetails = await storageService.getChannelDetails({ channelId });
             }
@@ -713,9 +976,12 @@ export const storageService = {
                 id: agentDetails.id,
                 name: agentDetails.name,
                 description: agentDetails.description || '',
+                image: agentDetails.image,
                 instructions: agentDetails.instructions || '',
-                runtime: agentDetails.runtime,
                 plugins: agentDetails.plugins,
+                pluginRefs: agentDetails.pluginRefs,
+                createdAt: agentDetails.createdAt,
+                updatedAt: agentDetails.updatedAt,
             },
             channelDetails: channelDetails,
             threadDetails: threadDetails,