openbot 0.4.0 → 0.4.2

package/dist/plugins/storage/files.js

@@ -0,0 +1,67 @@
+import { createReadStream } from 'node:fs';
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { resolvePath } from '../../app/config.js';
+const MIME_BY_EXT = {
+    '.png': 'image/png',
+    '.jpg': 'image/jpeg',
+    '.jpeg': 'image/jpeg',
+    '.gif': 'image/gif',
+    '.webp': 'image/webp',
+    '.svg': 'image/svg+xml',
+    '.ico': 'image/x-icon',
+    '.mp4': 'video/mp4',
+    '.webm': 'video/webm',
+    '.mov': 'video/quicktime',
+    '.mp3': 'audio/mpeg',
+    '.wav': 'audio/wav',
+    '.ogg': 'audio/ogg',
+    '.pdf': 'application/pdf',
+    '.json': 'application/json',
+    '.txt': 'text/plain',
+    '.html': 'text/html',
+    '.css': 'text/css',
+    '.js': 'text/javascript',
+    '.zip': 'application/zip',
+};
+export function guessMimeType(filePath) {
+    return MIME_BY_EXT[path.extname(filePath).toLowerCase()] ?? 'application/octet-stream';
+}
+/** Resolve a relative path under a channel cwd; rejects directory escape. */
+export function resolveChannelFile(baseCwd, relativePath) {
+    const resolvedBase = resolvePath(baseCwd);
+    const normalized = relativePath.replace(/\\/g, '/').replace(/^\/+/, '');
+    const target = path.resolve(resolvedBase, normalized);
+    if (target !== resolvedBase && !target.startsWith(resolvedBase + path.sep)) {
+        throw new Error('Access denied: directory escape');
+    }
+    return target;
+}
+export async function statChannelFile(baseCwd, relativePath) {
+    const abs = resolveChannelFile(baseCwd, relativePath);
+    const stat = await fs.stat(abs);
+    if (!stat.isFile()) {
+        throw new Error('Not a file');
+    }
+    return { abs, size: stat.size };
+}
+export function openChannelFileStream(abs) {
+    return createReadStream(abs);
+}
+export function buildWorkspaceFileUrl(args) {
+    const base = args.baseUrl.replace(/\/$/, '');
+    const data = encodeURIComponent(JSON.stringify({ path: args.filePath }));
+    const channelId = encodeURIComponent(args.channelId);
+    return `${base}/api/state?channelId=${channelId}&type=${encodeURIComponent('action:storage:serve-file')}&data=${data}`;
+}
+export function getPublicBaseUrl(port, configPublicUrl) {
+    const fromConfig = configPublicUrl?.trim();
+    if (fromConfig) {
+        return fromConfig.replace(/\/$/, '');
+    }
+    const fromEnv = process.env.OPENBOT_PUBLIC_URL?.trim();
+    if (fromEnv) {
+        return fromEnv.replace(/\/$/, '');
+    }
+    return `http://localhost:${port}`;
+}

package/dist/plugins/storage/index.js

@@ -1,4 +1,5 @@
 import z from 'zod';
+import { buildWorkspaceFileUrl } from './files.js';
 /**
  * `storage` — exposes channel/thread/variable mutation tools and provides
  * platform-level storage handlers.
@@ -21,7 +22,7 @@ const storageToolDefinitions = {
             cwd: z
                 .string()
                 .optional()
-                .describe('Optional initial current working directory for the channel.'),
+                .describe('Optional initial current working directory for the channel. Defaults to an absolute path under ~/openbot/{channelId}.'),
         }),
     },
     patch_channel_details: {
@@ -37,8 +38,15 @@ const storageToolDefinitions = {
                 .optional()
                 .describe('Markdown content for the channel specification (SPEC.md). Use for goals and rules.'),
             cwd: z.string().optional().describe('Current working directory for the channel.'),
+            participants: z
+                .array(z.string())
+                .optional()
+                .describe('List of agent IDs that are participants in this channel. When a user tags an agent (e.g. @agent-id), you should ensure they are added to this list if they are not already there.'),
         })
-            .refine((value) => value.state !== undefined || value.spec !== undefined || value.cwd !== undefined, { message: 'Provide at least one of state, spec, or cwd.' }),
+            .refine((value) => value.state !== undefined ||
+            value.spec !== undefined ||
+            value.cwd !== undefined ||
+            value.participants !== undefined, { message: 'Provide at least one of state, spec, cwd, or participants.' }),
     },
     patch_thread_details: {
         description: 'Patch current thread details (state).',
@@ -62,13 +70,28 @@ const storageToolDefinitions = {
             key: z.string().describe('The key of the variable to delete.'),
         }),
     },
+    delete_channel: {
+        description: 'Permanently delete a channel and all its threads and events. Always confirm with the user before deleting.',
+        inputSchema: z.object({
+            channelId: z.string().describe('The channel ID to delete.'),
+        }),
+    },
+    get_workspace_file_url: {
+        description: 'Get a fetchable HTTP URL for a file in the current channel workspace (images, video, audio, documents).',
+        inputSchema: z.object({
+            path: z
+                .string()
+                .describe('Path relative to the channel working directory, e.g. "uploads/clip.mp4".'),
+        }),
+    },
 };
 export const storagePlugin = {
     id: 'storage',
     name: 'Storage',
     description: 'Tools for creating channels, patching state, and managing workspace variables.',
     toolDefinitions: storageToolDefinitions,
-    factory: ({ storage }) => (builder) => {
+    factory: ({ storage, publicBaseUrl }) => (builder) => {
+        const resolvePublicBaseUrl = () => publicBaseUrl;
         builder.on('action:create_thread', async function* (event, context) {
             const threadId = event.meta?.threadId;
             const channelId = context.state.channelId;
@@ -151,6 +174,42 @@ export const storagePlugin = {
                 };
             }
         });
+        builder.on('action:delete_channel', async function* (event, context) {
+            const rawChannelId = (event.data?.channelId || '').trim();
+            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+            if (!rawChannelId) {
+                yield {
+                    type: 'action:delete_channel:result',
+                    data: { success: false, channelId: '', error: 'channelId is required' },
+                    meta: resultMeta,
+                };
+                return;
+            }
+            try {
+                await storage.deleteChannel({ channelId: rawChannelId });
+                yield {
+                    type: 'action:delete_channel:result',
+                    data: { success: true, channelId: rawChannelId },
+                    meta: resultMeta,
+                };
+                yield {
+                    type: 'agent:output',
+                    data: { content: `Deleted channel \`${rawChannelId}\`.` },
+                    meta: resultMeta,
+                };
+            }
+            catch (error) {
+                yield {
+                    type: 'action:delete_channel:result',
+                    data: {
+                        success: false,
+                        channelId: rawChannelId,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                    meta: resultMeta,
+                };
+            }
+        });
         builder.on('action:update_channel', async function* (event, context) {
             const data = (event.data || {});
             const targetChannelId = (data.channelId || context.state.channelId || '').trim();
@@ -256,7 +315,8 @@ export const storagePlugin = {
                         widgetId: "patch-channel-details-result" + Date.now(),
                         kind: "message",
                         title: "Channel details updated.",
-                        body: "The channel details have been updated.",
+                        body: `The channel details have been updated. ${updatedFields.join(', ')}`,
+                        display: "collapsed",
                     },
                     meta: resultMeta,
                 };
@@ -340,6 +400,26 @@ export const storagePlugin = {
             const threads = await storage.getThreads({ channelId: event.data.channelId });
             yield { type: 'action:storage:get-threads-result', data: { threads } };
         });
+        builder.on('action:storage:set-last-read', async function* (event, context) {
+            const { channelId, threadId, lastReadEventId } = event.data;
+            try {
+                await storage.setLastRead({
+                    channelId: channelId || context.state.channelId,
+                    threadId: threadId || context.state.threadId,
+                    lastReadEventId,
+                });
+                yield { type: 'action:storage:set-last-read-result', data: { success: true } };
+            }
+            catch (error) {
+                yield {
+                    type: 'action:storage:set-last-read-result',
+                    data: {
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                };
+            }
+        });
         builder.on('action:storage:get-channel-details', async function* (_, state) {
             const channelDetails = await storage.getChannelDetails({
                 channelId: state.state.channelId,
@@ -425,6 +505,21 @@ export const storagePlugin = {
                 };
             }
         });
+        builder.on('action:storage:delete-channel', async function* (event) {
+            try {
+                await storage.deleteChannel({ channelId: event.data.channelId });
+                yield { type: 'action:storage:delete-channel-result', data: { success: true } };
+            }
+            catch (error) {
+                yield {
+                    type: 'action:storage:delete-channel-result',
+                    data: {
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                };
+            }
+        });
         builder.on('action:storage:delete-agent', async function* (event) {
             try {
                 await storage.deleteAgent({ agentId: event.data.agentId });
@@ -542,7 +637,9 @@ export const storagePlugin = {
         });
         builder.on('action:storage:read-file', async function* (event, context) {
             const channelId = context.state.channelId;
-            const filePath = event.data?.path;
+            const data = event.data;
+            const filePath = data?.path;
+            const encoding = data?.encoding ?? 'utf8';
             if (!filePath) {
                 yield {
                     type: 'action:storage:read-file:result',
@@ -551,10 +648,22 @@ export const storagePlugin = {
                 return;
             }
             try {
-                const content = await storage.readFile({ channelId, path: filePath });
+                if (encoding === 'utf8') {
+                    const content = await storage.readFile({ channelId, path: filePath });
+                    yield {
+                        type: 'action:storage:read-file:result',
+                        data: { success: true, content, path: filePath, encoding },
+                    };
+                    return;
+                }
+                const { content, mimeType, size } = await storage.readChannelFile({
+                    channelId,
+                    path: filePath,
+                    encoding,
+                });
                 yield {
                     type: 'action:storage:read-file:result',
-                    data: { success: true, content, path: filePath },
+                    data: { success: true, content, path: filePath, encoding, mimeType, size },
                 };
             }
             catch (error) {
@@ -568,6 +677,74 @@ export const storagePlugin = {
                 };
             }
         });
+        builder.on('action:storage:get-file-url', async function* (event, context) {
+            const channelId = context.state.channelId;
+            const filePath = event.data?.path;
+            if (!filePath) {
+                yield {
+                    type: 'action:storage:get-file-url:result',
+                    data: { success: false, path: '', error: 'Path is required' },
+                };
+                return;
+            }
+            try {
+                const { size, mimeType } = await storage.getChannelFileStat({ channelId, path: filePath });
+                const url = buildWorkspaceFileUrl({
+                    baseUrl: resolvePublicBaseUrl(),
+                    channelId,
+                    filePath,
+                });
+                yield {
+                    type: 'action:storage:get-file-url:result',
+                    data: { success: true, path: filePath, url, mimeType, size },
+                };
+            }
+            catch (error) {
+                yield {
+                    type: 'action:storage:get-file-url:result',
+                    data: {
+                        success: false,
+                        path: filePath,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                };
+            }
+        });
+        builder.on('action:get_workspace_file_url', async function* (event, context) {
+            const channelId = context.state.channelId;
+            const filePath = event.data?.path;
+            const toolCallId = event.meta?.toolCallId;
+            if (!filePath) {
+                yield {
+                    type: 'action:get_workspace_file_url:result',
+                    data: { success: false, path: '', error: 'Path is required', output: 'Path is required' },
+                    meta: { ...(event.meta || {}), toolCallId },
+                };
+                return;
+            }
+            try {
+                const { size, mimeType } = await storage.getChannelFileStat({ channelId, path: filePath });
+                const url = buildWorkspaceFileUrl({
+                    baseUrl: resolvePublicBaseUrl(),
+                    channelId,
+                    filePath,
+                });
+                const output = JSON.stringify({ path: filePath, url, mimeType, size });
+                yield {
+                    type: 'action:get_workspace_file_url:result',
+                    data: { success: true, path: filePath, url, mimeType, size, output },
+                    meta: { ...(event.meta || {}), toolCallId },
+                };
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                yield {
+                    type: 'action:get_workspace_file_url:result',
+                    data: { success: false, path: filePath, error: message, output: message },
+                    meta: { ...(event.meta || {}), toolCallId },
+                };
+            }
+        });
     },
 };
 export default storagePlugin;