openbot 0.4.0 → 0.4.3

package/dist/plugins/storage/service.js

@@ -1,5 +1,5 @@
 import { ORCHESTRATOR_AGENT_ID, STATE_AGENT_ID } from '../../app/agent-ids.js';
-import { DEFAULT_PLUGINS_DIR, DEFAULT_AGENTS_DIR, DEFAULT_BASE_DIR, DEFAULT_CHANNELS_DIR, loadConfig, resolvePath, VARIABLES_FILE, } from '../../app/config.js';
+import { DEFAULT_PLUGINS_DIR, DEFAULT_AGENTS_DIR, DEFAULT_BASE_DIR, DEFAULT_CHANNELS_DIR, getDefaultChannelCwd, loadConfig, resolvePath, VARIABLES_FILE, } from '../../app/config.js';
 import fs from 'node:fs/promises';
 import { readFileSync } from 'node:fs';
 import path from 'node:path';
@@ -7,10 +7,10 @@ import { fileURLToPath, pathToFileURL } from 'node:url';
 import crypto from 'node:crypto';
 import matter from 'gray-matter';
 import { openbotPlugin } from '../openbot/index.js';
-import { OPENBOT_SYSTEM_PROMPT } from '../openbot/system-prompt.js';
 import { listBuiltInPlugins, parsePluginModule } from '../../services/plugins/registry.js';
 import { processService } from '../../services/process.js';
 import { memoryService } from '../memory/service.js';
+import { guessMimeType, resolveChannelFile, statChannelFile, } from './files.js';
 const resolveBaseDir = () => {
     const config = loadConfig();
     return resolvePath(config.baseDir || DEFAULT_BASE_DIR);
@@ -80,14 +80,17 @@ const getConversationDir = (channelId, threadId) => {
 /** Built-in orchestrator agent id. Not creatable as a normal disk agent. */
 const SYSTEM_AGENT_ID = ORCHESTRATOR_AGENT_ID;
 const SYSTEM_DEFAULT_PLUGINS = [
-    { id: 'openbot', config: { model: 'openai/gpt-5.4-mini' } },
-    { id: 'shell' },
-    { id: 'approval' },
-    { id: 'memory' },
-    { id: 'delegation' },
-    { id: 'storage' },
+    {
+        id: 'openbot',
+        config: {
+            model: 'openai/gpt-5.4-mini',
+            approval: {
+                actions: ['action:bash', 'action:create_channel', 'action:delete_channel'],
+            },
+        },
+    },
 ];
-/** No `openbot` / `shell` — storage-side effects and infra plugins only. */
+/** No `openbot` / `bash` — storage-side effects and infra plugins only. */
 const STATE_DEFAULT_PLUGINS = [
     { id: 'storage' },
     { id: 'plugin-manager' },
@@ -99,7 +102,7 @@ function getSystemAgentDetails(overrides) {
         name: 'OpenBot',
         image: getBundledSystemAgentImage(),
         description: 'First-party orchestration agent for OpenBot.',
-        instructions: OPENBOT_SYSTEM_PROMPT,
+        instructions: '',
         plugins: SYSTEM_DEFAULT_PLUGINS.map((ref) => ref.id),
         pluginRefs: SYSTEM_DEFAULT_PLUGINS,
         createdAt: new Date(),
@@ -179,6 +182,22 @@ const assertAgentIdFormat = (agentId) => {
 };
 const getAgentsRootDir = () => path.join(resolveBaseDir(), DEFAULT_AGENTS_DIR);
 const getLastReadFilePath = () => path.join(resolvePath(resolveBaseDir() + '/' + DEFAULT_CHANNELS_DIR), '_meta', 'last-read.json');
+/** Sentinel key for channel-root events (no threadId). */
+export const ROOT_THREAD_KEY = '__root__';
+const readLastReadMap = async () => {
+    const raw = await readJsonFile(getLastReadFilePath(), {});
+    const map = {};
+    for (const [channelId, value] of Object.entries(raw)) {
+        if (typeof value === 'string') {
+            // Migrate old format
+            map[channelId] = { [ROOT_THREAD_KEY]: value };
+        }
+        else if (value && typeof value === 'object') {
+            map[channelId] = value;
+        }
+    }
+    return map;
+};
 const THREAD_TITLE_MAX_LENGTH = 80;
 const buildThreadTitleFromEvent = (event) => {
     let rawContent = '';
@@ -197,14 +216,25 @@ const buildThreadTitleFromEvent = (event) => {
 };
 const readJsonFile = async (filePath, fallback) => {
     try {
-        return JSON.parse(await fs.readFile(filePath, 'utf-8'));
+        const content = (await fs.readFile(filePath, 'utf-8')).trim();
+        if (!content)
+            return fallback;
+        return JSON.parse(content);
     }
     catch (e) {
         if (e?.code === 'ENOENT')
             return fallback;
+        if (e instanceof SyntaxError)
+            return fallback;
         throw e;
     }
 };
+const writeJsonFileAtomically = async (filePath, data) => {
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    const tmp = `${filePath}.tmp`;
+    await fs.writeFile(tmp, JSON.stringify(data, null, 2), 'utf-8');
+    await fs.rename(tmp, filePath);
+};
 const toVariablesRecord = (raw) => {
     if (!raw || typeof raw !== 'object') {
         return {};
@@ -352,15 +382,19 @@ const parsePluginRefs = (raw) => {
 };
 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(), {});
+    getLastReadMap: async () => {
+        return readLastReadMap();
     },
-    setLastReadForChannel: async ({ channelId, lastReadEventId, }) => {
+    setLastRead: async ({ channelId, threadId, lastReadEventId, }) => {
         const p = getLastReadFilePath();
         await fs.mkdir(path.dirname(p), { recursive: true });
-        const map = await readJsonFile(p, {});
-        map[channelId] = lastReadEventId;
-        await fs.writeFile(p, JSON.stringify(map, null, 2), 'utf-8');
+        const map = await readLastReadMap();
+        if (!map[channelId])
+            map[channelId] = {};
+        map[channelId][threadId || ROOT_THREAD_KEY] = lastReadEventId;
+        const tmp = `${p}.tmp`;
+        await fs.writeFile(tmp, JSON.stringify(map, null, 2), 'utf-8');
+        await fs.rename(tmp, p);
     },
     getChannels: async () => {
         const channelsDir = resolvePath(resolveBaseDir() + '/' + DEFAULT_CHANNELS_DIR);
@@ -371,16 +405,16 @@ export const storageService = {
             await fs.mkdir(channelsDir, { recursive: true });
         }
         const channelNames = (await fs.readdir(channelsDir)).filter((name) => !name.startsWith('.') && name !== '_meta');
-        const lastReadByChannel = await storageService.getLastReadByChannel();
+        const lastReadMap = await storageService.getLastReadMap();
         const channels = await Promise.all(channelNames.map(async (name) => {
             const channelDir = getConversationDir(name);
+            const stats = await fs.stat(channelDir);
             const statePath = path.join(channelDir, 'state.json');
             let cwd;
             let displayName = name;
             let participants = [];
             try {
-                const stateContent = await fs.readFile(statePath, 'utf-8');
-                const parsed = JSON.parse(stateContent);
+                const parsed = await readJsonFile(statePath, {});
                 const fields = readChannelStateFileFields(parsed);
                 cwd = fields.cwd;
                 displayName = fields.name ?? name;
@@ -395,30 +429,30 @@ export const storageService = {
                 description: '',
                 cwd,
                 participants,
-                createdAt: new Date(),
-                updatedAt: new Date(),
+                createdAt: stats.birthtime,
+                updatedAt: stats.mtime,
             };
-            const rid = lastReadByChannel[name];
-            try {
-                const events = await storageService.getEvents({ channelId: name });
-                const latestId = events[events.length - 1]?.id;
-                channel.hasUnseenMessages = !!(latestId && latestId !== rid);
-            }
-            catch {
-                channel.hasUnseenMessages = false;
-            }
+            const channelLastRead = lastReadMap[name] || {};
             try {
+                // Check root unread
+                const rootEvents = await storageService.getEvents({ channelId: name });
+                const rootLatestId = rootEvents[rootEvents.length - 1]?.id;
+                const rootUnseen = !!(rootLatestId && rootLatestId !== channelLastRead[ROOT_THREAD_KEY]);
+                // Check threads unread
                 const allThreads = await storageService.getThreads({ channelId: name });
                 channel.recentThreads = allThreads
                     .sort((a, b) => b.updatedAt.getTime() - a.updatedAt.getTime())
                     .slice(0, 5);
+                const threadsUnseen = allThreads.some(t => t.hasUnseenMessages);
+                channel.hasUnseenMessages = rootUnseen || threadsUnseen;
             }
             catch {
+                channel.hasUnseenMessages = false;
                 channel.recentThreads = [];
             }
             return channel;
         }));
-        return channels;
+        return channels.sort((a, b) => b.createdAt.getTime() - a.createdAt.getTime());
     },
     createChannel: async ({ channelId, spec, initialState, cwd, }) => {
         const normalizedChannelId = channelId.trim();
@@ -441,13 +475,52 @@ export const storageService = {
         const finalState = {
             ...(initialState || {}),
         };
-        if (cwd) {
-            finalState.cwd = cwd;
-        }
+        const rawCwd = (typeof cwd === 'string' && cwd.trim()) ||
+            (typeof finalState.cwd === 'string' && finalState.cwd.trim()) ||
+            getDefaultChannelCwd(normalizedChannelId);
+        const resolvedCwd = resolvePath(rawCwd);
+        finalState.cwd = resolvedCwd;
+        await fs.mkdir(resolvedCwd, { recursive: true });
         await fs.mkdir(channelDir, { recursive: true });
         await fs.writeFile(specPath, spec?.trim() ||
-            `# ${normalizedChannelId}\n\nDefine the goals and rules for this channel here.\n`);
-        await fs.writeFile(statePath, JSON.stringify(finalState, null, 2));
+            `# ${normalizedChannelId}\n\n`);
+        await writeJsonFileAtomically(statePath, finalState);
+    },
+    deleteChannel: async ({ channelId }) => {
+        const normalizedChannelId = channelId.trim();
+        if (!normalizedChannelId) {
+            throw new Error('channelId is required');
+        }
+        if (normalizedChannelId === '_meta') {
+            throw new Error('Cannot delete reserved channel path');
+        }
+        const channelDir = getConversationDir(normalizedChannelId);
+        try {
+            await fs.access(channelDir);
+        }
+        catch (error) {
+            if (error?.code === 'ENOENT') {
+                const err = new Error(`Channel "${normalizedChannelId}" does not exist.`);
+                err.code = 'CHANNEL_NOT_FOUND';
+                throw err;
+            }
+            throw error;
+        }
+        await fs.rm(channelDir, { recursive: true, force: true });
+        try {
+            const lastReadPath = getLastReadFilePath();
+            const map = await readJsonFile(lastReadPath, {});
+            if (normalizedChannelId in map) {
+                delete map[normalizedChannelId];
+                await fs.mkdir(path.dirname(lastReadPath), { recursive: true });
+                const tmp = `${lastReadPath}.tmp`;
+                await fs.writeFile(tmp, JSON.stringify(map, null, 2), 'utf-8');
+                await fs.rename(tmp, lastReadPath);
+            }
+        }
+        catch {
+            // ignore last-read cleanup failures
+        }
     },
     createThread: async ({ channelId, threadId, threadTitle, initialState, }) => {
         const normalizedChannelId = channelId.trim();
@@ -472,8 +545,7 @@ export const storageService = {
         if (threadTitle?.trim()) {
             baseState.name = threadTitle.trim();
         }
-        await fs.mkdir(threadDir, { recursive: true });
-        await fs.writeFile(statePath, JSON.stringify(baseState, null, 2));
+        await writeJsonFileAtomically(statePath, baseState);
     },
     getThreads: async ({ channelId }) => {
         const threadsDir = resolvePath(resolveBaseDir() + '/' + DEFAULT_CHANNELS_DIR + '/' + channelId + '/threads');
@@ -483,6 +555,8 @@ export const storageService = {
         catch {
             return [];
         }
+        const lastReadMap = await storageService.getLastReadMap();
+        const channelLastRead = lastReadMap[channelId] || {};
         const threadNames = (await fs.readdir(threadsDir)).filter((name) => !name.startsWith('.'));
         const threads = await Promise.all(threadNames.map(async (name) => {
             const threadPath = path.join(threadsDir, name);
@@ -490,8 +564,7 @@ export const storageService = {
             const threadStatePath = path.join(threadPath, 'state.json');
             let threadDisplayName = name;
             try {
-                const threadStateRaw = await fs.readFile(threadStatePath, 'utf-8');
-                const threadState = JSON.parse(threadStateRaw);
+                const threadState = await readJsonFile(threadStatePath, {});
                 const threadName = typeof threadState.name === 'string' ? threadState.name.trim() : '';
                 if (threadName) {
                     threadDisplayName = threadName;
@@ -502,12 +575,22 @@ export const storageService = {
                     console.error(`Failed to read thread state for channel ${channelId} thread ${name}`, error);
                 }
             }
+            let hasUnseen = false;
+            try {
+                const events = await storageService.getEvents({ channelId, threadId: name });
+                const latestId = events[events.length - 1]?.id;
+                hasUnseen = !!(latestId && latestId !== channelLastRead[name]);
+            }
+            catch {
+                // ignore
+            }
             return {
                 id: name,
                 name: threadDisplayName,
                 channelId,
                 createdAt: stats.birthtime,
                 updatedAt: stats.mtime,
+                hasUnseenMessages: hasUnseen,
             };
         }));
         return threads;
@@ -517,8 +600,7 @@ export const storageService = {
         const statePath = `${threadDir}/state.json`;
         let state = {};
         try {
-            const stateContent = await fs.readFile(statePath, 'utf-8');
-            state = JSON.parse(stateContent);
+            state = await readJsonFile(statePath, {});
         }
         catch (error) {
             if (error?.code !== 'ENOENT') {
@@ -550,8 +632,7 @@ export const storageService = {
         }
         let state = {};
         try {
-            const stateContent = await fs.readFile(statePath, 'utf-8');
-            state = JSON.parse(stateContent);
+            state = await readJsonFile(statePath, {});
         }
         catch (error) {
             if (error?.code !== 'ENOENT') {
@@ -582,8 +663,7 @@ export const storageService = {
                 ...currentState,
                 ...patch,
             };
-            await fs.mkdir(channelDir, { recursive: true });
-            await fs.writeFile(statePath, JSON.stringify(newState, null, 2));
+            await writeJsonFileAtomically(statePath, newState);
         }
         catch (error) {
             console.error(`Failed to patch channel state for channel ${channelId}`, error);
@@ -600,8 +680,7 @@ export const storageService = {
                 ...currentState,
                 ...patch,
             };
-            await fs.mkdir(threadDir, { recursive: true });
-            await fs.writeFile(statePath, JSON.stringify(newState, null, 2));
+            await writeJsonFileAtomically(statePath, newState);
         }
         catch (error) {
             console.error(`Failed to patch thread state for channel ${channelId} thread ${threadId}`, error);
@@ -1074,11 +1153,9 @@ export const storageService = {
         if (!baseCwd) {
             throw new Error('Channel has no CWD configured');
         }
-        const resolvedBase = path.resolve(baseCwd);
-        const targetDir = path.resolve(resolvedBase, subPath);
-        if (!targetDir.startsWith(resolvedBase)) {
-            throw new Error('Access denied: directory escape');
-        }
+        const targetDir = subPath
+            ? resolveChannelFile(baseCwd, subPath)
+            : resolvePath(baseCwd);
         const entries = await fs.readdir(targetDir, { withFileTypes: true });
         return entries
             .filter((e) => !e.name.startsWith('.'))
@@ -1093,13 +1170,88 @@ export const storageService = {
         if (!baseCwd) {
             throw new Error('Channel has no CWD configured');
         }
-        const resolvedBase = path.resolve(baseCwd);
-        const targetFile = path.resolve(resolvedBase, filePath);
-        if (!targetFile.startsWith(resolvedBase)) {
-            throw new Error('Access denied: directory escape');
-        }
+        const targetFile = resolveChannelFile(baseCwd, filePath);
         return fs.readFile(targetFile, 'utf-8');
     },
+    readChannelFile: async ({ channelId, path: filePath, encoding = 'utf8', }) => {
+        const details = await storageService.getChannelDetails({ channelId });
+        const baseCwd = details.cwd;
+        if (!baseCwd) {
+            throw new Error('Channel has no CWD configured');
+        }
+        const targetFile = resolveChannelFile(baseCwd, filePath);
+        const buf = await fs.readFile(targetFile);
+        const content = encoding === 'base64' ? buf.toString('base64') : buf.toString('utf-8');
+        return {
+            content,
+            mimeType: guessMimeType(targetFile),
+            size: buf.length,
+        };
+    },
+    writeChannelFile: async ({ channelId, path: filePath, content, encoding = 'utf8', overwrite = false, }) => {
+        const details = await storageService.getChannelDetails({ channelId });
+        const baseCwd = details.cwd;
+        if (!baseCwd) {
+            throw new Error('Channel has no CWD configured');
+        }
+        const abs = resolveChannelFile(baseCwd, filePath);
+        await fs.mkdir(path.dirname(abs), { recursive: true });
+        if (!overwrite) {
+            try {
+                await fs.access(abs);
+                throw new Error('File already exists');
+            }
+            catch (error) {
+                const code = error?.code;
+                if (code !== 'ENOENT') {
+                    throw error;
+                }
+            }
+        }
+        const buf = encoding === 'base64' ? Buffer.from(content, 'base64') : Buffer.from(content, 'utf8');
+        await fs.writeFile(abs, buf);
+        return {
+            path: filePath,
+            size: buf.length,
+            mimeType: guessMimeType(abs),
+        };
+    },
+    uploadChannelFile: async ({ channelId, path: filePath, body, overwrite = false, }) => {
+        const details = await storageService.getChannelDetails({ channelId });
+        const baseCwd = details.cwd;
+        if (!baseCwd) {
+            throw new Error('Channel has no CWD configured');
+        }
+        const abs = resolveChannelFile(baseCwd, filePath);
+        await fs.mkdir(path.dirname(abs), { recursive: true });
+        if (!overwrite) {
+            try {
+                await fs.access(abs);
+                throw new Error('File already exists');
+            }
+            catch (error) {
+                const code = error?.code;
+                if (code !== 'ENOENT') {
+                    throw error;
+                }
+            }
+        }
+        await fs.writeFile(abs, body);
+        return {
+            path: filePath,
+            size: body.length,
+            mimeType: guessMimeType(abs),
+        };
+    },
+    getChannelFileStat: async ({ channelId, path: filePath, }) => {
+        const details = await storageService.getChannelDetails({ channelId });
+        const baseCwd = details.cwd;
+        if (!baseCwd) {
+            throw new Error('Channel has no CWD configured');
+        }
+        const { abs, size } = await statChannelFile(baseCwd, filePath);
+        return { abs, size, mimeType: guessMimeType(abs) };
+    },
     appendMemory: memoryService.appendMemory,
     listMemories: memoryService.listMemories,
     deleteMemory: memoryService.deleteMemory,
@@ -1135,12 +1287,16 @@ export const storageService = {
                 console.warn(`[storage] Failed to load thread details for channel ${channelId} thread: ${threadId}`, error);
             }
         }
+        const threadState = threadDetails?.state || {};
         return {
             runId,
             agentId,
             channelId,
             threadId,
             triggerEvent: event,
+            pendingToolCallIds: Array.isArray(threadState.pendingToolCallIds)
+                ? threadState.pendingToolCallIds
+                : undefined,
             agentDetails: {
                 id: agentDetails.id,
                 name: agentDetails.name,