verybot 0.1.3

package/dist/gateway/server.js

@@ -0,0 +1,133 @@
+import { createServer } from "node:http";
+import { readFile, stat } from "node:fs/promises";
+import { join, extname, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { WebSocketServer } from "ws";
+import { addClient, broadcast } from "./broadcast.js";
+import { createRpcDispatcher } from "./rpc.js";
+import { on } from "../events.js";
+import { logger } from "../logger.js";
+/** Bridge app-level events to WebSocket broadcast. */
+const BRIDGED_EVENTS = ["taskChange", "teamChange", "promptTemplateChange", "skillChange", "system", "agent", "chat", "whatsapp"];
+for (const event of BRIDGED_EVENTS) {
+    on(event, (payload) => broadcast(event, payload));
+}
+const MIME_TYPES = {
+    ".html": "text/html",
+    ".js": "application/javascript",
+    ".css": "text/css",
+    ".json": "application/json",
+    ".png": "image/png",
+    ".jpg": "image/jpeg",
+    ".svg": "image/svg+xml",
+    ".ico": "image/x-icon",
+    ".woff": "font/woff",
+    ".woff2": "font/woff2",
+    ".ttf": "font/ttf",
+};
+/** Resolve the control-ui dist directory (lives next to compiled gateway code). */
+function getUiDir() {
+    const thisFile = fileURLToPath(import.meta.url);
+    // dist/gateway/server.js -> dist/control-ui
+    return join(thisFile, "..", "..", "control-ui");
+}
+const SECURITY_HEADERS = {
+    "X-Content-Type-Options": "nosniff",
+    "X-Frame-Options": "DENY",
+    "Content-Security-Policy": "default-src 'self'; connect-src 'self' ws: wss:; style-src 'self' 'unsafe-inline'; font-src 'self'",
+};
+async function serveStatic(req, res) {
+    const uiDir = resolve(getUiDir());
+    const url = req.url ?? "/";
+    const pathname = decodeURIComponent(url.split("?")[0]);
+    // Resolve and guard against path traversal
+    let filePath = resolve(uiDir, pathname.replace(/^\/+/, "") || "index.html");
+    if (!filePath.startsWith(uiDir)) {
+        res.writeHead(403);
+        res.end("Forbidden");
+        return;
+    }
+    try {
+        const fileStat = await stat(filePath);
+        if (fileStat.isDirectory()) {
+            filePath = join(filePath, "index.html");
+        }
+        const content = await readFile(filePath);
+        const ext = extname(filePath);
+        res.writeHead(200, { "Content-Type": MIME_TYPES[ext] ?? "application/octet-stream", ...SECURITY_HEADERS });
+        res.end(content);
+    }
+    catch {
+        // SPA fallback: serve index.html for non-asset routes
+        try {
+            const indexPath = join(uiDir, "index.html");
+            const content = await readFile(indexPath);
+            res.writeHead(200, { "Content-Type": "text/html", ...SECURITY_HEADERS });
+            res.end(content);
+        }
+        catch {
+            res.writeHead(404);
+            res.end("Not found");
+        }
+    }
+}
+export function startGateway(port, token, getAgent, opts = {}) {
+    const WS_PATH = "/ws";
+    const server = createServer((req, res) => serveStatic(req, res));
+    const wss = new WebSocketServer({ noServer: true });
+    const dispatch = createRpcDispatcher(getAgent, opts);
+    // Only upgrade requests on the /ws path
+    server.on("upgrade", (req, socket, head) => {
+        if (req.url === WS_PATH) {
+            wss.handleUpgrade(req, socket, head, (ws) => wss.emit("connection", ws, req));
+        }
+        else {
+            socket.destroy();
+        }
+    });
+    wss.on("connection", (ws) => {
+        let authed = false;
+        ws.on("message", async (raw) => {
+            let msg;
+            try {
+                msg = JSON.parse(raw.toString());
+            }
+            catch {
+                ws.send(JSON.stringify({ error: "invalid json" }));
+                return;
+            }
+            // Auth handshake
+            if (msg.method === "connect") {
+                if (msg.token === token) {
+                    authed = true;
+                    addClient(ws);
+                    ws.send(JSON.stringify({ id: msg.id, result: { status: "ok" } }));
+                }
+                else {
+                    ws.send(JSON.stringify({ id: msg.id, error: "auth failed" }));
+                    ws.close();
+                }
+                return;
+            }
+            if (!authed) {
+                ws.send(JSON.stringify({ error: "not authenticated" }));
+                return;
+            }
+            // RPC dispatch
+            try {
+                const result = await dispatch(msg.method, msg.params, { ws });
+                ws.send(JSON.stringify({ id: msg.id, result }));
+            }
+            catch (err) {
+                ws.send(JSON.stringify({
+                    id: msg.id,
+                    error: err instanceof Error ? err.message : "unknown error",
+                }));
+            }
+        });
+    });
+    server.listen(port, () => {
+        logger.info(`Gateway listening on http://localhost:${port}`);
+    });
+    return server;
+}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,212 @@
+import { handleCli } from "./cli/index.js";
+import { loadConfig, seedConfigStore, injectSecretsIntoEnv } from "./config.js";
+import { ConfigStore } from "./config/store.js";
+import { BASE_DIR, SESSIONS_DIR, MEMORY_DB_PATH, SKILLS_DIR, ensureDirs } from "./paths.js";
+import { startGateway } from "./gateway/server.js";
+import { ChannelManager } from "./channels/manager.js";
+import { Agent } from "./brain/agent.js";
+import { ChannelStore } from "./brain/channel-store.js";
+import { DelegationStore } from "./brain/delegation-store.js";
+import { ToolRegistry } from "./tools/registry.js";
+import { webFetchTool } from "./tools/web-fetch.js";
+import { createFsTools } from "./tools/fs.js";
+import { DockerSandbox } from "./security/docker-sandbox.js";
+import { BrowserManager } from "./computer/browser/manager.js";
+import { createBrowserTools } from "./computer/browser/tools.js";
+import { createDesktopAdapter } from "./computer/desktop/adapter.js";
+import { MemoryStore } from "./memory/store.js";
+import { createEmbeddingProvider } from "./memory/embedding.js";
+import { loadSkills } from "./skills/loader.js";
+import { loadIntegrations } from "./integrations/registry.js";
+import { ScheduleStore } from "./scheduler/store.js";
+import { Scheduler } from "./scheduler/scheduler.js";
+import { ConnectedChannelRegistry } from "./scheduler/connected-channels.js";
+import { TaskStore } from "./tasks/store.js";
+import { TeamStore } from "./teams/store.js";
+import { PromptTemplateStore } from "./prompt-templates/store.js";
+import { BUILTIN_TEMPLATES } from "./prompt-templates/builtins.js";
+import { logger } from "./logger.js";
+// --- CLI subcommand routing (no gateway boot) ---
+if (handleCli())
+    process.exit(process.exitCode ?? 0);
+// Prevent unhandled errors from crashing the process
+process.on("uncaughtException", (err) => {
+    logger.error(`Uncaught exception: ${err instanceof Error ? err.stack ?? err.message : err}`);
+});
+process.on("unhandledRejection", (err) => {
+    logger.error(`Unhandled rejection: ${err instanceof Error ? err.stack ?? err.message : err}`);
+});
+async function teardown(rt) {
+    rt.scheduler.stop();
+    await rt.agent.flushMemories();
+    rt.agent.cleanupSandbox();
+    rt.skillManager.stopWatching();
+    await rt.integrationRegistry.cleanupAll();
+    await rt.browser.close();
+    rt.memoryStore?.close();
+    rt.scheduleStore.close();
+    rt.delegationStore?.close();
+    rt.channelStore?.close();
+    rt.taskStore.close();
+    rt.promptTemplateStore.close();
+    rt.teamStore.close();
+    await rt.channels.stopAll();
+}
+const SCHEDULER_TICK_MS = 5_000;
+async function boot(configStore) {
+    injectSecretsIntoEnv(configStore);
+    const config = loadConfig(configStore);
+    logger.info("Config loaded");
+    // --- Docker Sandbox ---
+    const sandbox = config.sandbox.enabled ? new DockerSandbox(config.sandbox) : null;
+    // --- Tools ---
+    const registry = new ToolRegistry();
+    if (config.bash.security === "deny") {
+        logger.info("Bash tool disabled (BASH_SECURITY=deny)");
+    }
+    registry.register("web_fetch", webFetchTool);
+    // --- Filesystem ---
+    for (const [name, t] of Object.entries(createFsTools({ sandboxed: !!sandbox }))) {
+        registry.register(name, t);
+    }
+    // --- Browser ---
+    const browser = new BrowserManager({
+        headless: config.browserHeadless,
+        userAgent: config.browserUserAgent || undefined,
+    });
+    for (const [name, t] of Object.entries(createBrowserTools(browser))) {
+        registry.register(name, t);
+    }
+    // --- Desktop ---
+    let desktopAdapter = null;
+    try {
+        desktopAdapter = await createDesktopAdapter();
+        logger.info(`Desktop adapter ready (${process.platform})`);
+    }
+    catch (err) {
+        logger.error(`Desktop adapter failed to initialize: ${err instanceof Error ? err.message : err}`);
+    }
+    // --- Skills ---
+    const skillManager = await loadSkills(SKILLS_DIR);
+    // --- Integrations ---
+    const integrationRegistry = await loadIntegrations(config, configStore);
+    // --- Memory ---
+    let memoryStore = null;
+    let embeddingProvider = null;
+    if (config.memory.enabled) {
+        memoryStore = await MemoryStore.create(MEMORY_DB_PATH);
+        embeddingProvider = await createEmbeddingProvider("local");
+        logger.info(`Memory enabled (embeddings: ${embeddingProvider ? embeddingProvider.id : "none"})`);
+    }
+    // --- Scheduler Store ---
+    const scheduleStore = await ScheduleStore.create(MEMORY_DB_PATH);
+    // --- Task store ---
+    const taskStore = await TaskStore.create(MEMORY_DB_PATH);
+    // --- Prompt template store (must exist before TeamStore for FK) ---
+    const promptTemplateStore = await PromptTemplateStore.create(MEMORY_DB_PATH);
+    promptTemplateStore.seedBuiltins(BUILTIN_TEMPLATES);
+    // --- Team store (SQLite-backed, managed via UI/RPC) ---
+    const teamStore = await TeamStore.create(MEMORY_DB_PATH);
+    const teamConfigs = teamStore.toTeamConfigs();
+    // --- Multi-agent stores (TeamRegistry is created lazily by reloadConfig) ---
+    const hasWorkers = teamConfigs.some((t) => t.workers.length > 0);
+    let delegationStore = null;
+    let channelStore = null;
+    if (hasWorkers) {
+        delegationStore = await DelegationStore.create(MEMORY_DB_PATH);
+        channelStore = await ChannelStore.create(MEMORY_DB_PATH);
+    }
+    // --- Channels (created before Agent so it can reconcile them on config reload) ---
+    const channels = new ChannelManager();
+    // --- Connected Channels (scheduler live connections) ---
+    const connectedChannels = new ConnectedChannelRegistry();
+    // --- Agent ---
+    const agent = new Agent({
+        config,
+        configStore,
+        tools: registry.getAll(),
+        dataDir: SESSIONS_DIR,
+        memoryStore,
+        embeddingProvider,
+        sandbox,
+        skillManager,
+        integrationRegistry,
+        scheduleStore,
+        desktopAdapter,
+        browserManager: browser,
+        delegationStore,
+        channelStore,
+        taskStore,
+        teamStore,
+        channelManager: channels,
+        connectedChannels,
+    });
+    // Initial channel setup — reuses the same reconcile path as hot-reload
+    await agent.initChannels();
+    // --- Scheduler ---
+    const scheduler = new Scheduler(scheduleStore, agent, connectedChannels, SCHEDULER_TICK_MS);
+    scheduler.start();
+    logger.info("Runtime booted");
+    return { agent, scheduler, channels, connectedChannels, browser, skillManager, integrationRegistry, memoryStore, embeddingProvider, scheduleStore, delegationStore, channelStore, taskStore, promptTemplateStore, teamStore, sandbox };
+}
+/* ------------------------------------------------------------------ */
+/*  Main: gateway is long-lived, runtime is swappable                  */
+/* ------------------------------------------------------------------ */
+async function main() {
+    ensureDirs();
+    const configStore = new ConfigStore(BASE_DIR);
+    seedConfigStore(configStore);
+    // Mutable runtime ref — swapped on hot restart
+    let runtime = await boot(configStore);
+    /** Delay after teardown before booting — lets Telegram release the getUpdates long-poll. */
+    const RESTART_SETTLE_MS = 2_000;
+    const restart = async () => {
+        logger.info("Hot restart: tearing down...");
+        await teardown(runtime);
+        logger.info(`Hot restart: waiting ${RESTART_SETTLE_MS}ms for connections to settle...`);
+        await new Promise((r) => setTimeout(r, RESTART_SETTLE_MS));
+        logger.info("Hot restart: booting...");
+        runtime = await boot(configStore);
+    };
+    // Gateway survives restarts — RPC methods resolve agent via getter
+    const config = loadConfig(configStore);
+    startGateway(config.gateway.port, config.gateway.token, () => runtime.agent, {
+        configStore,
+        restart,
+        getTaskStore: () => runtime.taskStore,
+        getTeamStore: () => runtime.teamStore,
+        getScheduleStore: () => runtime.scheduleStore,
+        getConnectedChannels: () => runtime.connectedChannels,
+        getSkillManager: () => runtime.skillManager,
+        getMemoryStore: () => runtime.memoryStore,
+        getEmbeddingProvider: () => runtime.embeddingProvider,
+        getPromptTemplateStore: () => runtime.promptTemplateStore,
+    });
+    // --- Graceful shutdown ---
+    let shuttingDown = false;
+    const shutdown = async () => {
+        if (shuttingDown)
+            return process.exit(1);
+        shuttingDown = true;
+        logger.info("Shutting down...");
+        const forceTimer = setTimeout(() => {
+            logger.warn("Shutdown timed out, forcing exit");
+            process.exit(1);
+        }, 5_000);
+        forceTimer.unref();
+        try {
+            await teardown(runtime);
+        }
+        catch (err) {
+            logger.error(`Shutdown error: ${err}`);
+        }
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    logger.info("Agent running. Waiting for messages...");
+}
+main().catch((err) => {
+    logger.error(`Fatal: ${err}`);
+    process.exit(1);
+});

package/dist/integrations/github.d.ts

@@ -0,0 +1,7 @@
+import type { Integration } from "./types.js";
+interface GithubConfig {
+    token: string;
+    defaultOwner?: string;
+}
+export declare function createGithubIntegration(config: GithubConfig): Integration;
+export {};

package/dist/integrations/github.js

@@ -0,0 +1,133 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { Octokit } from "octokit";
+import { logger } from "../logger.js";
+const MAX_ISSUES_PER_PAGE = 30;
+/** Zod schema for GitHub integration config. */
+const githubConfigSchema = z.object({
+    token: z.string().min(1),
+    defaultOwner: z.string().optional(),
+});
+/** Flat config.json keys → GithubConfig fields. */
+const GITHUB_CONFIG_KEYS = {
+    token: "GITHUB_TOKEN",
+    defaultOwner: "GITHUB_DEFAULT_OWNER",
+};
+export function createGithubIntegration(config) {
+    const octokit = new Octokit({ auth: config.token });
+    const tools = {
+        github_create_issue: tool({
+            description: "Create a new GitHub issue in a repository",
+            inputSchema: z.object({
+                owner: z.string().describe("Repository owner (user or org)"),
+                repo: z.string().describe("Repository name"),
+                title: z.string().describe("Issue title"),
+                body: z.string().optional().describe("Issue body (markdown)"),
+                labels: z.array(z.string()).optional().describe("Labels to apply"),
+            }),
+            execute: async ({ owner, repo, title, body, labels }) => {
+                try {
+                    const { data } = await octokit.rest.issues.create({
+                        owner: owner ?? config.defaultOwner ?? "",
+                        repo,
+                        title,
+                        body,
+                        labels,
+                    });
+                    return `Created issue #${data.number}: ${data.html_url}`;
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    logger.error(`github_create_issue failed: ${msg}`);
+                    return `Error creating issue: ${msg}`;
+                }
+            },
+        }),
+        github_list_issues: tool({
+            description: "List issues in a GitHub repository",
+            inputSchema: z.object({
+                owner: z.string().describe("Repository owner (user or org)"),
+                repo: z.string().describe("Repository name"),
+                state: z.enum(["open", "closed", "all"]).optional().describe("Filter by state (default: open)"),
+                labels: z.string().optional().describe("Comma-separated label names to filter by"),
+                limit: z
+                    .number()
+                    .optional()
+                    .describe(`Max issues to return (default: ${MAX_ISSUES_PER_PAGE})`),
+            }),
+            execute: async ({ owner, repo, state, labels, limit }) => {
+                try {
+                    const { data } = await octokit.rest.issues.listForRepo({
+                        owner: owner ?? config.defaultOwner ?? "",
+                        repo,
+                        state: state ?? "open",
+                        labels,
+                        per_page: Math.min(limit ?? MAX_ISSUES_PER_PAGE, 100),
+                    });
+                    if (data.length === 0)
+                        return "No issues found.";
+                    return data
+                        .map((i) => `#${i.number} [${i.state}] ${i.title} — ${i.html_url}`)
+                        .join("\n");
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    logger.error(`github_list_issues failed: ${msg}`);
+                    return `Error listing issues: ${msg}`;
+                }
+            },
+        }),
+        github_create_pr: tool({
+            description: "Create a pull request in a GitHub repository",
+            inputSchema: z.object({
+                owner: z.string().describe("Repository owner (user or org)"),
+                repo: z.string().describe("Repository name"),
+                title: z.string().describe("PR title"),
+                body: z.string().optional().describe("PR description (markdown)"),
+                head: z.string().describe("Branch containing changes"),
+                base: z.string().describe("Branch to merge into (e.g., 'main')"),
+            }),
+            execute: async ({ owner, repo, title, body, head, base }) => {
+                try {
+                    const { data } = await octokit.rest.pulls.create({
+                        owner: owner ?? config.defaultOwner ?? "",
+                        repo,
+                        title,
+                        body,
+                        head,
+                        base,
+                    });
+                    return `Created PR #${data.number}: ${data.html_url}`;
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    logger.error(`github_create_pr failed: ${msg}`);
+                    return `Error creating PR: ${msg}`;
+                }
+            },
+        }),
+    };
+    return {
+        id: "github",
+        name: "github",
+        source: "builtin",
+        tools: {
+            tools,
+            systemPrompt: [
+                "## GitHub Integration",
+                "You have GitHub tools available:",
+                "- `github_create_issue`: Create a new issue in a repo",
+                "- `github_list_issues`: List issues in a repo",
+                "- `github_create_pr`: Create a pull request",
+            ].join("\n"),
+            initialize: async () => {
+                const { data } = await octokit.rest.users.getAuthenticated();
+                logger.info(`GitHub integration ready (authenticated as ${data.login})`);
+            },
+        },
+        config: {
+            schema: githubConfigSchema,
+            configKeys: GITHUB_CONFIG_KEYS,
+        },
+    };
+}

package/dist/integrations/mcp.d.ts

@@ -0,0 +1,7 @@
+import type { McpServerConfig } from "../config.js";
+import type { Integration } from "./types.js";
+/**
+ * Create an Integration from an MCP server config.
+ * Connects to the server, discovers tools, and wraps them as Vercel AI SDK tools.
+ */
+export declare function createMcpIntegration(name: string, config: McpServerConfig): Promise<Integration>;

package/dist/integrations/mcp.js

@@ -0,0 +1,106 @@
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
+import { tool, jsonSchema } from "ai";
+import { logger } from "../logger.js";
+/** Agent name sent to MCP servers during initialization. */
+const CLIENT_NAME = "mvp-agent";
+const CLIENT_VERSION = "1.0.0";
+/**
+ * Format MCP tool result content array into a string for the model.
+ */
+function formatMcpResult(content) {
+    if (!Array.isArray(content))
+        return String(content);
+    return content
+        .map((item) => {
+        if (item.type === "text")
+            return item.text;
+        if (item.type === "image")
+            return `[image: ${item.mimeType}]`;
+        if (item.type === "resource") {
+            const resource = item.resource;
+            return resource.text ?? `[resource: ${resource.uri}]`;
+        }
+        return JSON.stringify(item);
+    })
+        .join("\n");
+}
+/**
+ * Create an Integration from an MCP server config.
+ * Connects to the server, discovers tools, and wraps them as Vercel AI SDK tools.
+ */
+export async function createMcpIntegration(name, config) {
+    const client = new Client({ name: CLIENT_NAME, version: CLIENT_VERSION }, { capabilities: {} });
+    let transport;
+    if (config.command && config.url) {
+        logger.warn(`MCP server "${name}": both "command" and "url" specified; using "command" (stdio)`);
+    }
+    if (config.command) {
+        transport = new StdioClientTransport({
+            command: config.command,
+            args: config.args ?? [],
+            env: { ...process.env, ...config.env },
+        });
+    }
+    else if (config.url) {
+        transport = new SSEClientTransport(new URL(config.url));
+    }
+    else {
+        throw new Error(`MCP server "${name}": config must have either "command" (stdio) or "url" (SSE)`);
+    }
+    // Connect and discover tools
+    await client.connect(transport);
+    const { tools: mcpTools } = await client.listTools();
+    // Convert MCP tools → Vercel AI SDK tools
+    const tools = {};
+    for (const mcpTool of mcpTools) {
+        const toolName = mcpTool.name;
+        tools[toolName] = tool({
+            description: mcpTool.description ?? `MCP tool: ${toolName}`,
+            inputSchema: jsonSchema(mcpTool.inputSchema),
+            execute: async (params) => {
+                try {
+                    const result = await client.callTool({
+                        name: toolName,
+                        arguments: params,
+                    });
+                    if (result.isError) {
+                        return `Error: ${formatMcpResult(result.content)}`;
+                    }
+                    return formatMcpResult(result.content);
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    logger.error(`MCP tool "${toolName}" failed: ${msg}`);
+                    return `Error calling ${toolName}: ${msg}`;
+                }
+            },
+        });
+    }
+    const toolNames = Object.keys(tools).join(", ");
+    return {
+        id: `mcp:${name}`,
+        name,
+        source: "mcp",
+        tools: {
+            tools,
+            systemPrompt: [
+                `## MCP: ${name}`,
+                `Connected MCP server with tools: ${toolNames}.`,
+            ].join("\n"),
+            initialize: async () => {
+                logger.info(`MCP server "${name}" connected (${config.command ? "stdio" : "sse"}, ${mcpTools.length} tools: ${toolNames})`);
+            },
+            cleanup: async () => {
+                try {
+                    await client.close();
+                    logger.info(`MCP server "${name}" disconnected`);
+                }
+                catch (err) {
+                    logger.warn(`MCP server "${name}" cleanup error: ${err instanceof Error ? err.message : err}`);
+                }
+            },
+        },
+    };
+}

package/dist/integrations/registry.d.ts

@@ -0,0 +1,43 @@
+import type { ToolSet } from "ai";
+import type { ConfigStore } from "../config/store.js";
+import type { Config } from "../config.js";
+import type { Integration } from "./types.js";
+/**
+ * Holds all available integrations (initialized at startup).
+ * Tools are NOT registered globally — they are injected per-session
+ * based on which integrations are active.
+ */
+export declare class IntegrationRegistry {
+    private integrations;
+    register(integration: Integration): void;
+    get(name: string): Integration | undefined;
+    has(name: string): boolean;
+    /** Get all available integration names. */
+    get names(): string[];
+    /** Get tools for the given active integration names. */
+    getToolsFor(active: Set<string>): ToolSet;
+    /** Get system prompts for the given active integration names. */
+    getPromptsFor(active: Set<string>): string[];
+    /** Clean up all integrations that have a cleanup method (e.g. MCP connections). */
+    cleanupAll(): Promise<void>;
+    /**
+     * Re-discover builtin and user integrations from the ConfigStore.
+     * Adds newly-configured integrations, removes ones whose keys were deleted.
+     * MCP integrations are left untouched (they're long-lived connections).
+     */
+    refresh(store: ConfigStore, integrationsDir: string): Promise<void>;
+    /** Re-discover builtin integrations. */
+    private refreshBuiltins;
+    /** Re-discover user integrations from the integrations directory. */
+    private refreshUserIntegrations;
+    /** Build a compact listing of all available integrations for the system prompt. */
+    buildListing(active?: Set<string>): string;
+}
+/**
+ * Initialize all configured integrations and return a registry.
+ * Builtin integrations are auto-discovered via ConfigAdapter.configKeys.
+ * User integrations are loaded from the integrations directory.
+ * MCP servers are loaded from config.mcpServers.
+ * Continues past individual failures (logs error, skips that integration).
+ */
+export declare function loadIntegrations(config: Config, store: ConfigStore): Promise<IntegrationRegistry>;