verybot 0.1.8

package/dist/teams/types.d.ts

@@ -0,0 +1,30 @@
+import type { TaskStatusConfig } from "../config/agent-config.js";
+export interface Team {
+    id: string;
+    name: string;
+    color: string;
+    workspace: string;
+    /** Custom task statuses (null/undefined = defaults). */
+    statuses?: TaskStatusConfig[];
+    createdAt: number;
+    updatedAt: number;
+}
+export interface AgentRow {
+    id: string;
+    teamId: string;
+    name: string;
+    role: "orchestrator" | "worker";
+    model: string;
+    contextWindow: number;
+    maxSteps: number;
+    identity: string;
+    tools: string[];
+    timeout: number;
+    templateId: string | null;
+    /** Task statuses this agent subscribes to for pull-based execution. */
+    subscriptions: string[];
+    /** Max concurrent tasks this agent can run simultaneously. */
+    concurrency: number;
+    createdAt: number;
+    updatedAt: number;
+}

package/dist/teams/types.js

@@ -0,0 +1 @@
+export {};

package/dist/tools/bash.d.ts

@@ -0,0 +1,18 @@
+import { type Tool } from "ai";
+import type { BashConfig } from "../config.js";
+import type { DockerSandbox } from "../security/docker-sandbox.js";
+/** Per-run context injected when creating the bash tool inside Agent.run(). */
+export interface BashToolContext {
+    sessionKey: string;
+    sandbox: DockerSandbox | null;
+    /** Optional host working directory for command execution. */
+    cwd?: string;
+}
+/**
+ * Create a bash tool with the given security config and optional per-run context.
+ * Returns null in "deny" mode (tool not registered at all).
+ *
+ * When `ctx.sandbox` is provided, commands execute inside a Docker container.
+ * Otherwise, commands execute on the host with sanitized environment.
+ */
+export declare function createBashTool(config: BashConfig, ctx?: BashToolContext): Tool | null;

package/dist/tools/bash.js

@@ -0,0 +1,64 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { execSync } from "child_process";
+import { validateCommand, isAllowed, DEFAULT_SAFE_BINS } from "../security/command-validator.js";
+import { sanitizeEnv } from "../security/env-filter.js";
+import { logger } from "../logger.js";
+const EXEC_TIMEOUT = 30_000;
+const MAX_OUTPUT = 10_000;
+const MAX_ERROR = 5_000;
+/**
+ * Create a bash tool with the given security config and optional per-run context.
+ * Returns null in "deny" mode (tool not registered at all).
+ *
+ * When `ctx.sandbox` is provided, commands execute inside a Docker container.
+ * Otherwise, commands execute on the host with sanitized environment.
+ */
+export function createBashTool(config, ctx) {
+    if (config.security === "deny")
+        return null;
+    // Merge user-provided safe bins with defaults
+    const safeBins = new Set([...DEFAULT_SAFE_BINS, ...config.safeBins]);
+    return tool({
+        description: "Execute a shell command. Confirm with user before destructive commands (rm, mv, chmod). " +
+            "Backticks, $(), redirects, and subshells are blocked.",
+        inputSchema: z.object({
+            command: z.string().describe("The shell command to execute"),
+        }),
+        execute: async ({ command }) => {
+            // 1. Always validate syntax (blocks dangerous tokens in all modes)
+            const validation = validateCommand(command);
+            if (!validation.ok) {
+                logger.warn(`Bash blocked (syntax): ${validation.reason} — ${command}`);
+                return `Blocked: ${validation.reason}`;
+            }
+            // 2. In allowlist mode, check executables against safe bins + allowlist
+            if (config.security === "allowlist") {
+                if (!isAllowed(command, safeBins, config.allowlist)) {
+                    logger.warn(`Bash blocked (allowlist): ${command}`);
+                    return `Blocked: command not in allowlist. Safe bins: ${[...safeBins].join(", ")}`;
+                }
+            }
+            // 3. Execute — sandbox if available, otherwise host
+            if (ctx?.sandbox) {
+                return ctx.sandbox.exec(ctx.sessionKey, command);
+            }
+            try {
+                const cwd = ctx?.cwd?.trim() || undefined;
+                const output = execSync(command, {
+                    encoding: "utf-8",
+                    timeout: EXEC_TIMEOUT,
+                    maxBuffer: 1024 * 1024,
+                    env: sanitizeEnv(),
+                    cwd,
+                });
+                return output.slice(0, MAX_OUTPUT);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                const stderr = err.stderr ?? "";
+                return `Error: ${msg}\n${stderr}`.slice(0, MAX_ERROR);
+            }
+        },
+    });
+}

package/dist/tools/channel-history.d.ts

@@ -0,0 +1,10 @@
+import { type Tool } from "ai";
+import type { ChannelManager } from "../channels/manager.js";
+/**
+ * Create a read_channel_history tool that lets the LLM fetch recent messages
+ * from the current messaging channel (Slack, etc.) on demand.
+ *
+ * The channelId is resolved fresh at execution time from a callback
+ * to avoid stale closures.
+ */
+export declare function createChannelHistoryTool(channelManager: ChannelManager, channelType: string, resolveChannelId: () => string): Tool | null;

package/dist/tools/channel-history.js

@@ -0,0 +1,43 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { logger } from "../logger.js";
+/** Default number of messages to fetch. */
+const DEFAULT_LIMIT = 20;
+/**
+ * Create a read_channel_history tool that lets the LLM fetch recent messages
+ * from the current messaging channel (Slack, etc.) on demand.
+ *
+ * The channelId is resolved fresh at execution time from a callback
+ * to avoid stale closures.
+ */
+export function createChannelHistoryTool(channelManager, channelType, resolveChannelId) {
+    const ch = channelManager.get(channelType);
+    if (!ch?.readHistory)
+        return null;
+    return tool({
+        description: "Read recent messages from the current chat channel or thread. " +
+            "Use this when the user references prior conversation, asks what was discussed, " +
+            "or needs context about the channel's recent messages. " +
+            "Returns messages in chronological order.",
+        inputSchema: z.object({
+            limit: z
+                .number()
+                .int()
+                .min(1)
+                .max(50)
+                .optional()
+                .describe("Number of recent messages to fetch (default 20, max 50)"),
+        }),
+        execute: async ({ limit }) => {
+            const channelId = resolveChannelId();
+            logger.info(`[channel-history] Reading ${channelType}/${channelId} limit=${limit ?? DEFAULT_LIMIT}`);
+            const messages = await ch.readHistory(channelId, limit ?? DEFAULT_LIMIT);
+            if (messages.length === 0)
+                return `No messages found in channel ${channelId}.`;
+            const formatted = messages
+                .map((m) => `<@${m.user}>: ${m.text}`)
+                .join("\n");
+            return `[${channelType} channel ${channelId} — ${messages.length} messages]\n${formatted}`;
+        },
+    });
+}

package/dist/tools/delegate.d.ts

@@ -0,0 +1,20 @@
+import { type ToolSet } from "ai";
+import type { AgentRegistry } from "../brain/agent-registry.js";
+import type { ChannelStore } from "../brain/channel-store.js";
+import type { DelegationStore } from "../brain/delegation-store.js";
+import type { SessionStore } from "../brain/session-store.js";
+import type { MemoryStore } from "../memory/store.js";
+import type { EmbeddingProvider } from "../memory/embedding.js";
+import { type BrowserConfig } from "../computer/browser/manager.js";
+/**
+ * Creates delegation tools:
+ * - `delegate`      — fires a worker in background, returns channel ID immediately
+ * - `list_workers`  — lists worker names
+ * - `worker_get`    — gets full config for one worker
+ * - `read_channel`  — reads all messages from a channel (available to orchestrator AND workers)
+ */
+export declare function createDelegationTools(registry: AgentRegistry, channelStore: ChannelStore, delegationStore: DelegationStore, sessionStore: SessionStore, orchestratorId: string, sessionKey: string, memoryStore: MemoryStore | null, embeddingProvider: EmbeddingProvider | null, memoryMaxResults: number, onWorkerComplete: (sessionKey: string, channelId: string) => void, browserConfig: BrowserConfig | null, 
+/** Human-readable session label for logs (team name instead of UUID). */
+sessionLabel?: string, 
+/** Whether docker sandboxing is enabled (forwarded to MCP adapter). */
+sandboxEnabled?: boolean): ToolSet;

package/dist/tools/delegate.js

@@ -0,0 +1,299 @@
+import { randomUUID } from "crypto";
+import { tool } from "ai";
+import { z } from "zod";
+import { Session } from "../brain/session.js";
+import { buildSystemPrompt } from "../brain/context.js";
+import { runLoop } from "../brain/loop.js";
+import { adaptTools } from "../brain/mcp-adapter.js";
+import { buildUserMessageContent } from "../brain/user-content.js";
+import { createMemorySearchTool } from "./memory.js";
+import { emit } from "../events.js";
+import { logger } from "../logger.js";
+import { resolveInlineAttachmentContent } from "../tasks/inline-attachment-content.js";
+import { BrowserManager } from "../computer/browser/manager.js";
+import { createBrowserTools, BROWSER_TOOL_NAMES } from "../computer/browser/tools.js";
+import { DEFAULT_WORKER_TIMEOUT_S } from "../config/agent-config.js";
+import { parseModelSpec } from "../config/model-spec.js";
+/**
+ * Creates delegation tools:
+ * - `delegate`      — fires a worker in background, returns channel ID immediately
+ * - `list_workers`  — lists worker names
+ * - `worker_get`    — gets full config for one worker
+ * - `read_channel`  — reads all messages from a channel (available to orchestrator AND workers)
+ */
+export function createDelegationTools(registry, channelStore, delegationStore, sessionStore, orchestratorId, sessionKey, memoryStore, embeddingProvider, memoryMaxResults, onWorkerComplete, browserConfig, 
+/** Human-readable session label for logs (team name instead of UUID). */
+sessionLabel, 
+/** Whether docker sandboxing is enabled (forwarded to MCP adapter). */
+sandboxEnabled = false) {
+    const delegatable = registry.delegatableWorkers();
+    const idToName = registry.buildIdToNameMap();
+    const listWorkersToolName = "list_workers";
+    const workerGetToolName = "worker_get";
+    const delegate = tool({
+        description: `Delegate a task to a specialized worker agent. Returns immediately with a channel ID — the worker runs in the background. ` +
+            `You will be automatically notified when workers finish. Use read_channel to see results. ` +
+            `Use ${listWorkersToolName} to discover available worker names. ` +
+            `You can fire multiple delegations in the same step — they all run concurrently. ` +
+            `Pass contextChannels to give the worker read access to other workers' channels.`,
+        inputSchema: z.object({
+            worker: z
+                .string()
+                .describe("Which worker name to delegate to"),
+            task: z
+                .string()
+                .describe("Self-contained task description for the worker"),
+            contextChannels: z
+                .array(z.string())
+                .optional()
+                .describe("Channel IDs the worker can read for context from other workers"),
+        }),
+        execute: async ({ worker, task, contextChannels }) => {
+            const resolved = registry.resolveWorker(worker);
+            if (!resolved) {
+                return `Unknown worker: ${worker}. Call ${listWorkersToolName} to see available workers.`;
+            }
+            const { agentConfig, model, tools: workerBaseTools } = resolved;
+            const agentId = agentConfig.id;
+            const agentName = agentConfig.name;
+            // Create channel for this delegation
+            const channelId = channelStore.createChannel();
+            channelStore.post(channelId, orchestratorId, "task", task);
+            // Record in delegation store (uses DB id for storage)
+            const delegationId = randomUUID().slice(0, 8);
+            delegationStore.insert({
+                id: delegationId,
+                agentId,
+                sessionKey,
+                task,
+                channelId,
+                status: "running",
+                createdAt: Date.now(),
+            });
+            // Worker tools: base (filtered) + memory_search (read-only) + read_channel
+            // Give worker its own browser instance (temp profile) so it doesn't conflict with others
+            const hasBrowserTools = BROWSER_TOOL_NAMES.some((n) => n in workerBaseTools);
+            let workerBrowser = null;
+            const workerTools = { ...workerBaseTools };
+            if (hasBrowserTools && browserConfig) {
+                // Strip shared browser tools, replace with per-worker instance
+                for (const n of BROWSER_TOOL_NAMES)
+                    delete workerTools[n];
+                workerBrowser = new BrowserManager({ ...browserConfig, profileDir: "temp" });
+                Object.assign(workerTools, createBrowserTools(workerBrowser));
+            }
+            if (memoryStore) {
+                workerTools.memory_search = createMemorySearchTool(memoryStore, embeddingProvider, memoryMaxResults);
+            }
+            // Workers can read channels (their own + any context channels)
+            workerTools.read_channel = createReadChannelTool(channelStore, idToName);
+            // Build context hint about available channels
+            let channelHint = "";
+            if (contextChannels?.length) {
+                channelHint = `\n\nYou have access to read_channel. Context channels from other workers: ${contextChannels.join(", ")}. Call read_channel to see their results before starting your work.`;
+            }
+            const system = buildSystemPrompt({
+                identity: agentConfig.identity,
+                hasMemory: memoryStore !== null,
+            });
+            // Worker key extends parent key: {parentSessionKey}:{workerName}:{timestamp}
+            const workerSessionKey = `${sessionKey}:${agentName}:${Date.now()}`;
+            const session = new Session(workerSessionKey);
+            const workerTaskInput = task + channelHint;
+            const { normalizedText, imageDataUrls } = await resolveInlineAttachmentContent(workerTaskInput);
+            session.append({
+                role: "user",
+                content: buildUserMessageContent(normalizedText, imageDataUrls),
+            });
+            logger.info(`[delegate] ${orchestratorId} -> ${agentName}: ${task.slice(0, 200)} (channel: ${channelId})`);
+            emit("agent", {
+                sessionKey,
+                delegation: { agentId, agentName, channelId, status: "started" },
+            });
+            // Fire worker in background with timeout — does NOT await
+            const workerMaxSteps = agentConfig.maxSteps > 0 ? agentConfig.maxSteps : undefined;
+            const workerLabel = sessionLabel ? `worker:${sessionLabel}:${agentName}` : undefined;
+            const parsedWorkerModel = parseModelSpec(agentConfig.model);
+            const workerProvider = parsedWorkerModel.provider;
+            const workerModelId = parsedWorkerModel.modelId;
+            const workerCodexReasoningEffort = parsedWorkerModel.codexReasoningEffort;
+            // Extract team name from sessionLabel (format: "TeamName:channel:id...") for worker metadata
+            const teamName = sessionLabel?.split(":")[0];
+            const timeoutMs = (agentConfig.timeout ?? DEFAULT_WORKER_TIMEOUT_S) * 1_000;
+            withTimeout(runWorker(agentId, agentName, model, workerProvider, workerModelId, workerCodexReasoningEffort, system, session, workerTools, workerSessionKey, workerMaxSteps, workerLabel, sandboxEnabled), timeoutMs, `Worker ${agentName} timed out after ${timeoutMs / 1_000}s`).then(({ text: result, responseMessages }) => {
+                // Persist worker session with full tool call detail
+                for (const msg of responseMessages)
+                    session.append(msg);
+                sessionStore.save(session).then(() => {
+                    // Enrich worker session metadata for UI display
+                    sessionStore.updateMetadata(workerSessionKey, {
+                        channelType: "worker",
+                        agentId,
+                        agentName,
+                        ...(teamName ? { teamName } : {}),
+                    });
+                }).catch((err) => {
+                    logger.warn(`[delegate] Failed to save worker session ${workerSessionKey}: ${err instanceof Error ? err.message : err}`);
+                });
+                // Close the worker's own browser instance
+                cleanupWorkerBrowser(workerBrowser, agentName);
+                channelStore.post(channelId, agentId, "result", result);
+                delegationStore.markCompleted(delegationId, result);
+                logger.info(`[delegate] ${agentName} completed (${result.length} chars, channel: ${channelId})`);
+                emit("agent", {
+                    sessionKey,
+                    delegation: { agentId, agentName, channelId, status: "completed", resultLength: result.length },
+                });
+                onWorkerComplete(sessionKey, channelId);
+            }, (err) => {
+                const error = err instanceof Error ? err.message : String(err);
+                // Persist worker session even on failure for debugging
+                sessionStore.save(session).then(() => {
+                    sessionStore.updateMetadata(workerSessionKey, {
+                        channelType: "worker",
+                        agentId,
+                        agentName,
+                        ...(teamName ? { teamName } : {}),
+                    });
+                }).catch((saveErr) => {
+                    logger.warn(`[delegate] Failed to save worker session ${workerSessionKey}: ${saveErr instanceof Error ? saveErr.message : saveErr}`);
+                });
+                // Close the worker's own browser instance even on failure
+                cleanupWorkerBrowser(workerBrowser, agentName);
+                channelStore.post(channelId, agentId, "error", error);
+                delegationStore.markFailed(delegationId, error);
+                logger.error(`[delegate] ${agentName} failed: ${error} (channel: ${channelId})`);
+                emit("agent", {
+                    sessionKey,
+                    delegation: { agentId, agentName, channelId, status: "failed", error },
+                });
+                onWorkerComplete(sessionKey, channelId);
+            });
+            return `Delegated to ${agentName}. Channel: ${channelId}`;
+        },
+    });
+    const listWorkers = tool({
+        description: "List available worker names you can delegate tasks to.",
+        inputSchema: z.object({}),
+        execute: async () => {
+            if (delegatable.length === 0)
+                return "No workers available.";
+            return `Available workers:\n${delegatable.map((name) => `- ${name}`).join("\n")}`;
+        },
+    });
+    const workerGet = tool({
+        description: "Get full configuration details for one worker by name (identity, tools, model, limits, subscriptions).",
+        inputSchema: z.object({
+            worker: z.string().describe("Worker name to inspect"),
+        }),
+        execute: async ({ worker }) => {
+            const workerConfig = registry.getWorker(worker);
+            if (!workerConfig) {
+                return `Unknown worker: ${worker}. Call ${listWorkersToolName} to see available workers.`;
+            }
+            return formatWorkerDetails(workerConfig, workerGetToolName);
+        },
+    });
+    const readChannel = createReadChannelTool(channelStore, idToName);
+    return {
+        delegate,
+        list_workers: listWorkers,
+        worker_get: workerGet,
+        read_channel: readChannel,
+    };
+}
+/** Standalone read_channel tool — reused by both orchestrator and workers. */
+function createReadChannelTool(channelStore, nameMap) {
+    return tool({
+        description: "Read all messages from a delegation channel. Returns the full conversation log " +
+            "including tasks, results, and errors posted by any agent.",
+        inputSchema: z.object({
+            channelId: z
+                .string()
+                .describe("The channel ID to read"),
+        }),
+        execute: async ({ channelId }) => {
+            const messages = channelStore.read(channelId);
+            if (messages.length === 0)
+                return `Channel ${channelId}: no messages yet.`;
+            return messages
+                .map((m) => `[${nameMap?.get(m.sender) ?? m.sender}] (${m.role}): ${m.content}`)
+                .join("\n\n");
+        },
+    });
+}
+const DEFAULT_WORKER_MAX_STEPS = 20;
+/** Run a worker's loop — returned promise settles when done. */
+async function runWorker(agentId, agentName, model, provider, modelId, codexReasoningEffort, system, session, tools, workerSessionKey, maxSteps, sessionLabel, sandboxEnabled = false) {
+    let cleanup;
+    try {
+        const adapted = await adaptTools(provider, modelId, model, tools, {
+            sandboxEnabled,
+            codexReasoningEffort,
+        });
+        cleanup = adapted.cleanup;
+        return await runLoop({
+            model: adapted.model,
+            system,
+            messages: session.getMessages(),
+            tools: adapted.tools,
+            sessionKey: workerSessionKey,
+            sessionLabel,
+            agentId,
+            maxSteps: maxSteps ?? DEFAULT_WORKER_MAX_STEPS,
+            silent: true,
+        });
+    }
+    catch (err) {
+        const error = err instanceof Error ? err.message : String(err);
+        logger.error(`[delegate] ${agentName} worker failed: ${error}`);
+        throw err;
+    }
+    finally {
+        if (cleanup) {
+            try {
+                await cleanup();
+            }
+            catch (err) {
+                logger.warn(`[delegate] ${agentName} worker MCP cleanup failed: ${err instanceof Error ? err.message : err}`);
+            }
+        }
+    }
+}
+/** Close the browser if the worker had it open. No-op if no browser or already closed. */
+function cleanupWorkerBrowser(browserManager, agentName) {
+    if (!browserManager?.isLaunched())
+        return;
+    browserManager.close().catch((err) => {
+        logger.warn(`[delegate] ${agentName} browser cleanup failed: ${err instanceof Error ? err.message : err}`);
+    });
+}
+function formatWorkerDetails(worker, workerGetToolName) {
+    const toolsList = worker.tools.length > 0 ? worker.tools.join(", ") : "(all tools)";
+    const subscriptionsList = worker.subscriptions.length > 0 ? worker.subscriptions.join(", ") : "(none)";
+    const templateId = worker.templateId ?? "(none)";
+    const identity = worker.identity.trim() || "(empty)";
+    return [
+        `Worker: ${worker.name}`,
+        `- id: ${worker.id}`,
+        `- model: ${worker.model}`,
+        `- contextWindow: ${worker.contextWindow}`,
+        `- maxSteps: ${worker.maxSteps}`,
+        `- timeoutSeconds: ${worker.timeout}`,
+        `- concurrency: ${worker.concurrency}`,
+        `- subscriptions: ${subscriptionsList}`,
+        `- templateId: ${templateId}`,
+        `- tools: ${toolsList}`,
+        `- identity:`,
+        identity,
+        "",
+        `Tip: use ${workerGetToolName} with another name to inspect a different worker.`,
+    ].join("\n");
+}
+/** Race a promise against a timeout. */
+function withTimeout(promise, ms, message) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error(message)), ms);
+        promise.then((val) => { clearTimeout(timer); resolve(val); }, (err) => { clearTimeout(timer); reject(err); });
+    });
+}

package/dist/tools/fs.d.ts

@@ -0,0 +1,4 @@
+import { type Tool } from "ai";
+export declare function createFsTools(opts?: {
+    sandboxed?: boolean;
+}): Record<string, Tool>;