@meetopenbot/openbot 0.1.1

package/dist/tools/memory.js

@@ -0,0 +1,163 @@
+import z from 'zod';
+import { asActionBuilder } from '../types.js';
+/**
+ * Resolve a scope alias to a concrete scope string. Aliases let tools accept
+ * `agent`/`channel`/`global` without knowing the active ids; the bus rewrites
+ * them using `context.state`.
+ */
+function resolveMemoryScope(alias, state) {
+    switch (alias) {
+        case 'agent':
+            return `agent:${state.agentId}`;
+        case 'channel':
+            return `channel:${state.channelId}`;
+        case 'global':
+        case undefined:
+            return 'global';
+        default:
+            return 'global';
+    }
+}
+function resolveMemoryScopeFilter(alias, state) {
+    if (alias === 'all' || alias === undefined) {
+        return ['global', `agent:${state.agentId}`, `channel:${state.channelId}`];
+    }
+    return [resolveMemoryScope(alias, state)];
+}
+/**
+ * `memory` — exposes the global memory store as agent tools and provides
+ * platform-level memory handlers.
+ */
+const memoryToolDefinitions = {
+    remember: {
+        description: 'Persist a durable fact, preference, or note to long-term memory so it can be recalled in future turns and runs. Use for stable information (user preferences, project conventions, contact details, decisions); avoid using it for transient chatter or per-step scratch state — that belongs in thread state. Keep entries short and self-contained.',
+        inputSchema: z.object({
+            content: z
+                .string()
+                .min(1)
+                .describe('The fact to remember, written so it makes sense out of context (e.g. "User prefers TypeScript over JavaScript.").'),
+            scope: z
+                .enum(['global', 'agent', 'channel'])
+                .optional()
+                .describe('Visibility: `global` (default, all agents everywhere), `agent` (only this agent), `channel` (only this channel).'),
+            tags: z
+                .array(z.string())
+                .optional()
+                .describe('Optional tags for filtering with `recall`.'),
+        }),
+    },
+    recall: {
+        description: 'Search long-term memory for facts you previously stored with `remember`. Returns up to `limit` matching records with their ids so you can `forget` stale ones.',
+        inputSchema: z.object({
+            query: z
+                .string()
+                .optional()
+                .describe('Case-insensitive substring filter against memory content.'),
+            tag: z.string().optional().describe('Only return memories that include this tag.'),
+            scope: z
+                .enum(['global', 'agent', 'channel', 'all'])
+                .optional()
+                .describe('Restrict the search to a single scope. Default `all` returns global + this agent + this channel.'),
+            limit: z
+                .number()
+                .int()
+                .positive()
+                .max(50)
+                .optional()
+                .describe('Maximum records to return (default 20, max 50).'),
+        }),
+    },
+    forget: {
+        description: 'Delete a memory by id. Use after the user asks to forget something or when a previously remembered fact is now wrong. Get ids from `recall`.',
+        inputSchema: z.object({
+            id: z.string().describe('The memory record id (returned by `recall`/`remember`).'),
+        }),
+    },
+};
+export const memoryPlugin = {
+    id: 'memory',
+    name: 'Memory',
+    description: 'Global long-term memory: remember/recall/forget facts across runs and agents.',
+    toolDefinitions: memoryToolDefinitions,
+    factory: ({ storage }) => (builder) => {
+        const store = storage;
+        const actions = asActionBuilder(builder);
+        actions.on('remember', async function* (event, context) {
+            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+            try {
+                const { content, scope, tags } = event.data;
+                const record = await store.appendMemory({
+                    scope: resolveMemoryScope(scope, context.state),
+                    content,
+                    tags,
+                });
+                yield {
+                    type: 'action:remember:result',
+                    data: { success: true, record },
+                    meta: resultMeta,
+                };
+            }
+            catch (error) {
+                yield {
+                    type: 'action:remember:result',
+                    data: {
+                        success: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                    meta: resultMeta,
+                };
+            }
+        });
+        actions.on('recall', async function* (event, context) {
+            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+            try {
+                const { query, tag, scope, limit } = event.data;
+                const records = await store.listMemories({
+                    scopes: resolveMemoryScopeFilter(scope, context.state),
+                    query,
+                    tag,
+                    limit,
+                });
+                yield {
+                    type: 'action:recall:result',
+                    data: { success: true, records },
+                    meta: resultMeta,
+                };
+            }
+            catch (error) {
+                yield {
+                    type: 'action:recall:result',
+                    data: {
+                        success: false,
+                        records: [],
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                    meta: resultMeta,
+                };
+            }
+        });
+        actions.on('forget', async function* (event, context) {
+            const resultMeta = { ...(event.meta || {}), agentId: context.state.agentId };
+            try {
+                const deleted = await store.deleteMemory({ id: event.data.id });
+                yield {
+                    type: 'action:forget:result',
+                    data: { success: true, deleted },
+                    meta: resultMeta,
+                };
+            }
+            catch (error) {
+                yield {
+                    type: 'action:forget:result',
+                    data: {
+                        success: false,
+                        deleted: false,
+                        error: error instanceof Error ? error.message : 'Unknown error',
+                    },
+                    meta: resultMeta,
+                };
+            }
+        });
+    },
+};
+export default memoryPlugin;

package/dist/tools/preview.d.ts

@@ -0,0 +1,4 @@
+import type { Plugin } from '../types.js';
+export declare const stopPreviewForChannel: (channelId: string) => void;
+export declare const previewPlugin: Plugin;
+export default previewPlugin;

package/dist/tools/preview.js

@@ -0,0 +1,269 @@
+import { z } from 'zod';
+import { spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+import { asActionBuilder } from '../types.js';
+const TUNNEL_URL_PATTERN = /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i;
+const TUNNEL_READY_TIMEOUT_MS = 60000;
+const MAX_LOG_CHARS = 8000;
+const previewToolDefinitions = {
+    expose_port: {
+        description: 'Expose a local dev server port via a temporary public Cloudflare quick tunnel. Returns a previewUrl stored on the channel. Dev servers must listen on 0.0.0.0 or 127.0.0.1. Call after shell_exec when the server is ready.',
+        inputSchema: z.object({
+            port: z
+                .number()
+                .int()
+                .min(1024)
+                .max(65535)
+                .describe('Local port of the running dev server (e.g. 5173).'),
+        }),
+    },
+    unexpose_port: {
+        description: 'Stop the active Cloudflare preview tunnel for this channel and clear previewUrl from channel state.',
+        inputSchema: z.object({}),
+    },
+};
+const tunnels = new Map();
+const tunnelByChannel = new Map();
+const blockedPorts = () => {
+    const openbotPort = Number(process.env.PORT ?? 4132);
+    return new Set([22, 80, 443, openbotPort]);
+};
+const appendLog = (tunnel, chunk) => {
+    tunnel.logs += chunk;
+    if (tunnel.logs.length > MAX_LOG_CHARS) {
+        tunnel.logs = tunnel.logs.slice(-MAX_LOG_CHARS);
+    }
+};
+const killTunnelProcess = (tunnel) => {
+    const { process: child } = tunnel;
+    if (!child.pid) {
+        try {
+            child.kill();
+        }
+        catch {
+            /* ignore */
+        }
+        return;
+    }
+    try {
+        child.kill('SIGTERM');
+    }
+    catch {
+        try {
+            child.kill();
+        }
+        catch {
+            /* ignore */
+        }
+    }
+};
+const removeTunnel = (tunnelId) => {
+    const tunnel = tunnels.get(tunnelId);
+    if (!tunnel)
+        return;
+    killTunnelProcess(tunnel);
+    tunnels.delete(tunnelId);
+    if (tunnelByChannel.get(tunnel.channelId) === tunnelId) {
+        tunnelByChannel.delete(tunnel.channelId);
+    }
+};
+export const stopPreviewForChannel = (channelId) => {
+    const tunnelId = tunnelByChannel.get(channelId);
+    if (tunnelId) {
+        removeTunnel(tunnelId);
+    }
+};
+const waitForTunnelUrl = (child, timeoutMs) => new Promise((resolve, reject) => {
+    let buffer = '';
+    let settled = false;
+    const cleanup = () => {
+        clearTimeout(timer);
+        child.stdout?.off('data', onData);
+        child.stderr?.off('data', onData);
+        child.off('exit', onExit);
+        child.off('error', onError);
+    };
+    const tryParse = () => {
+        const match = buffer.match(TUNNEL_URL_PATTERN);
+        if (match) {
+            settled = true;
+            cleanup();
+            resolve(match[0]);
+        }
+    };
+    const onData = (chunk) => {
+        buffer += chunk.toString();
+        if (buffer.length > 16000) {
+            buffer = buffer.slice(-16000);
+        }
+        tryParse();
+    };
+    const onExit = (code) => {
+        if (settled)
+            return;
+        settled = true;
+        cleanup();
+        reject(new Error(`cloudflared exited before providing a tunnel URL (code ${code ?? 'unknown'})`));
+    };
+    const onError = (err) => {
+        if (settled)
+            return;
+        settled = true;
+        cleanup();
+        reject(err);
+    };
+    const timer = setTimeout(() => {
+        if (settled)
+            return;
+        settled = true;
+        cleanup();
+        reject(new Error('Timed out waiting for Cloudflare tunnel URL'));
+    }, timeoutMs);
+    child.stdout?.on('data', onData);
+    child.stderr?.on('data', onData);
+    child.on('exit', onExit);
+    child.on('error', onError);
+    tryParse();
+});
+const startCloudflaredTunnel = async (channelId, port) => {
+    const child = spawn('cloudflared', ['tunnel', '--url', `http://127.0.0.1:${port}`, '--no-autoupdate'], {
+        env: process.env,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const tunnel = {
+        id: randomUUID(),
+        channelId,
+        port,
+        url: '',
+        process: child,
+        startedAt: Date.now(),
+        logs: '',
+    };
+    child.stdout?.on('data', (data) => appendLog(tunnel, data.toString()));
+    child.stderr?.on('data', (data) => appendLog(tunnel, data.toString()));
+    child.on('exit', () => {
+        tunnels.delete(tunnel.id);
+        if (tunnelByChannel.get(channelId) === tunnel.id) {
+            tunnelByChannel.delete(channelId);
+        }
+    });
+    const url = await waitForTunnelUrl(child, TUNNEL_READY_TIMEOUT_MS);
+    tunnel.url = url;
+    tunnels.set(tunnel.id, tunnel);
+    tunnelByChannel.set(channelId, tunnel.id);
+    return tunnel;
+};
+const clearPreviewChannelState = async (storage, channelId) => {
+    await storage.patchChannelState({
+        channelId,
+        state: {
+            previewUrl: null,
+            previewPort: null,
+            previewExposedAt: null,
+        },
+    });
+};
+const previewPluginRuntime = (storage) => (builder) => {
+    const actions = asActionBuilder(builder);
+    actions.on('expose_port', async function* (event, context) {
+        const channelId = context.state.channelId;
+        const port = event.data?.port;
+        if (!Number.isInteger(port)) {
+            yield {
+                type: 'action:expose_port:result',
+                data: {
+                    success: false,
+                    output: 'port must be an integer between 1024 and 65535.',
+                },
+                meta: event.meta,
+            };
+            return;
+        }
+        if (blockedPorts().has(port)) {
+            yield {
+                type: 'action:expose_port:result',
+                data: {
+                    success: false,
+                    output: `Port ${port} is reserved and cannot be exposed.`,
+                },
+                meta: event.meta,
+            };
+            return;
+        }
+        const existingTunnelId = tunnelByChannel.get(channelId);
+        if (existingTunnelId) {
+            removeTunnel(existingTunnelId);
+        }
+        try {
+            const tunnel = await startCloudflaredTunnel(channelId, port);
+            await storage.patchChannelState({
+                channelId,
+                state: {
+                    previewUrl: tunnel.url,
+                    previewPort: port,
+                    previewExposedAt: tunnel.startedAt,
+                },
+            });
+            if (context.state.channelDetails) {
+                context.state.channelDetails = await storage.getChannelDetails({ channelId });
+            }
+            yield {
+                type: 'action:expose_port:result',
+                data: {
+                    success: true,
+                    previewUrl: tunnel.url,
+                    port,
+                    temporary: true,
+                    output: `Preview available at ${tunnel.url} (temporary Cloudflare quick tunnel).`,
+                },
+                meta: event.meta,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to start Cloudflare tunnel';
+            const needsCloudflared = message.includes('ENOENT') || message.toLowerCase().includes('cloudflared');
+            const hint = needsCloudflared
+                ? ' Install cloudflared and ensure it is on PATH (https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/downloads/).'
+                : '';
+            yield {
+                type: 'action:expose_port:result',
+                data: {
+                    success: false,
+                    error: message,
+                    output: `${message}${hint}`,
+                },
+                meta: event.meta,
+            };
+        }
+    });
+    actions.on('unexpose_port', async function* (event, context) {
+        const channelId = context.state.channelId;
+        stopPreviewForChannel(channelId);
+        await clearPreviewChannelState(storage, channelId);
+        if (context.state.channelDetails) {
+            context.state.channelDetails = await storage.getChannelDetails({ channelId });
+        }
+        yield {
+            type: 'action:unexpose_port:result',
+            data: {
+                success: true,
+                output: 'Preview tunnel stopped and previewUrl cleared from channel state.',
+            },
+            meta: event.meta,
+        };
+    });
+    actions.on('delete_channel', async function* (event) {
+        const channelId = event.data?.channelId;
+        if (channelId) {
+            stopPreviewForChannel(channelId);
+        }
+    });
+};
+export const previewPlugin = {
+    id: 'preview',
+    name: 'Preview',
+    description: 'Temporary public preview URLs via Cloudflare quick tunnels.',
+    toolDefinitions: previewToolDefinitions,
+    factory: ({ storage }) => previewPluginRuntime(storage),
+};
+export default previewPlugin;

package/dist/tools/storage.d.ts

@@ -0,0 +1,57 @@
+import z from 'zod';
+import type { PluginBuilder, PluginContext } from '../types.js';
+export declare function registerStorageTools(context: PluginContext): (builder: PluginBuilder) => void;
+export declare const storageToolPlugin: {
+    toolDefinitions: {
+        create_channel: {
+            description: string;
+            inputSchema: z.ZodObject<{
+                channelId: z.ZodString;
+                spec: z.ZodOptional<z.ZodString>;
+                initialState: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                cwd: z.ZodOptional<z.ZodString>;
+            }, z.z.core.$strip>;
+        };
+        patch_channel_details: {
+            description: string;
+            inputSchema: z.ZodObject<{
+                state: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                spec: z.ZodOptional<z.ZodString>;
+                cwd: z.ZodOptional<z.ZodString>;
+            }, z.z.core.$strip>;
+        };
+        patch_thread_details: {
+            description: string;
+            inputSchema: z.ZodObject<{
+                state: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            }, z.z.core.$strip>;
+        };
+        create_variable: {
+            description: string;
+            inputSchema: z.ZodObject<{
+                key: z.ZodString;
+                value: z.ZodString;
+                secret: z.ZodOptional<z.ZodBoolean>;
+            }, z.z.core.$strip>;
+        };
+        delete_variable: {
+            description: string;
+            inputSchema: z.ZodObject<{
+                key: z.ZodString;
+            }, z.z.core.$strip>;
+        };
+        delete_channel: {
+            description: string;
+            inputSchema: z.ZodObject<{
+                channelId: z.ZodString;
+            }, z.z.core.$strip>;
+        };
+        get_workspace_file_url: {
+            description: string;
+            inputSchema: z.ZodObject<{
+                path: z.ZodString;
+            }, z.z.core.$strip>;
+        };
+    };
+    register: typeof registerStorageTools;
+};