verybot 0.1.8

package/dist/integrations/registry.d.ts

@@ -0,0 +1,47 @@
+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;
+    private mcpConfigSignatures;
+    register(integration: Integration): void;
+    recordMcpConfigSignature(name: string, server: Config["mcpServers"][string]): 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, user, and MCP integrations from the ConfigStore.
+     * Adds newly-configured integrations, removes ones whose keys were deleted.
+     */
+    refresh(store: ConfigStore, integrationsDir: string, config: Config): Promise<void>;
+    /** Re-discover builtin integrations. */
+    private refreshBuiltins;
+    /** Re-discover user integrations from the integrations directory. */
+    private refreshUserIntegrations;
+    private static mcpSignature;
+    /** Reconcile MCP integrations against config.mcpServers (add/update/remove). */
+    private refreshMcpIntegrations;
+    /** 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>;

package/dist/integrations/registry.js

@@ -0,0 +1,332 @@
+import { INTEGRATIONS_DIR } from "../paths.js";
+import { createGithubIntegration } from "./github.js";
+import { createTwitterIntegration } from "./twitter.js";
+import { createMcpIntegration } from "./mcp.js";
+import { scanUserIntegrations } from "./scanner.js";
+import { logger } from "../logger.js";
+/** Registry of builtin integration factories keyed by id. */
+const BUILTIN_FACTORIES = {
+    github: (c) => createGithubIntegration(c),
+    twitter: (c) => createTwitterIntegration(c),
+};
+/**
+ * Holds all available integrations (initialized at startup).
+ * Tools are NOT registered globally — they are injected per-session
+ * based on which integrations are active.
+ */
+export class IntegrationRegistry {
+    integrations = new Map();
+    mcpConfigSignatures = new Map();
+    register(integration) {
+        this.integrations.set(integration.name, integration);
+    }
+    recordMcpConfigSignature(name, server) {
+        this.mcpConfigSignatures.set(name, IntegrationRegistry.mcpSignature(server));
+    }
+    get(name) {
+        return this.integrations.get(name);
+    }
+    has(name) {
+        return this.integrations.has(name);
+    }
+    /** Get all available integration names. */
+    get names() {
+        return Array.from(this.integrations.keys());
+    }
+    /** Get tools for the given active integration names. */
+    getToolsFor(active) {
+        const tools = {};
+        for (const name of active) {
+            const integration = this.integrations.get(name);
+            if (integration)
+                Object.assign(tools, integration.tools.tools);
+        }
+        return tools;
+    }
+    /** Get system prompts for the given active integration names. */
+    getPromptsFor(active) {
+        const prompts = [];
+        for (const name of active) {
+            const integration = this.integrations.get(name);
+            if (integration?.tools.systemPrompt)
+                prompts.push(integration.tools.systemPrompt);
+        }
+        return prompts;
+    }
+    /** Clean up all integrations that have a cleanup method (e.g. MCP connections). */
+    async cleanupAll() {
+        for (const [name, integration] of this.integrations) {
+            if (integration.tools.cleanup) {
+                try {
+                    await integration.tools.cleanup();
+                }
+                catch (err) {
+                    logger.warn(`Integration "${name}" cleanup failed: ${err instanceof Error ? err.message : err}`);
+                }
+            }
+        }
+    }
+    /**
+     * Re-discover builtin, user, and MCP integrations from the ConfigStore.
+     * Adds newly-configured integrations, removes ones whose keys were deleted.
+     */
+    async refresh(store, integrationsDir, config) {
+        try {
+            await this.refreshBuiltins(store);
+        }
+        catch (err) {
+            logger.error(`Builtin integration refresh failed: ${err instanceof Error ? err.message : err}`);
+        }
+        try {
+            await this.refreshUserIntegrations(store, integrationsDir);
+        }
+        catch (err) {
+            logger.error(`User integration refresh failed: ${err instanceof Error ? err.message : err}`);
+        }
+        try {
+            await this.refreshMcpIntegrations(config);
+        }
+        catch (err) {
+            logger.error(`MCP integration refresh failed: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    /** Re-discover builtin integrations. */
+    async refreshBuiltins(store) {
+        for (const [id, factory] of Object.entries(BUILTIN_FACTORIES)) {
+            const resolved = resolveBuiltinConfig(id, store);
+            const existing = this.integrations.get(id);
+            if (resolved && !existing) {
+                const integration = factory(resolved);
+                try {
+                    await integration.tools.initialize();
+                    this.register(integration);
+                    logger.info(`Integration "${id}" discovered and ready`);
+                }
+                catch (err) {
+                    logger.error(`Integration "${id}" failed to initialize: ${err instanceof Error ? err.message : err}`);
+                }
+            }
+            else if (!resolved && existing && existing.source !== "mcp" && existing.source !== "user") {
+                if (existing.tools.cleanup) {
+                    try {
+                        await existing.tools.cleanup();
+                    }
+                    catch { /* best-effort */ }
+                }
+                this.integrations.delete(id);
+                logger.info(`Integration "${id}" removed (config keys no longer present)`);
+            }
+        }
+    }
+    /** Re-discover user integrations from the integrations directory. */
+    async refreshUserIntegrations(store, dir) {
+        const scanned = await scanUserIntegrations(dir, store);
+        const scannedIds = new Set(scanned.map((i) => i.id));
+        // Remove user integrations that are no longer present on disk
+        for (const [name, existing] of this.integrations) {
+            if (existing.source === "user" && !scannedIds.has(existing.id)) {
+                if (existing.tools.cleanup) {
+                    try {
+                        await existing.tools.cleanup();
+                    }
+                    catch { /* best-effort */ }
+                }
+                this.integrations.delete(name);
+                logger.info(`User integration "${name}" removed (file no longer present)`);
+            }
+        }
+        // Add/update user integrations
+        for (const integration of scanned) {
+            const existing = this.integrations.get(integration.name);
+            if (existing)
+                continue; // Already registered — skip re-init
+            try {
+                await integration.tools.initialize();
+                this.register(integration);
+                logger.info(`User integration "${integration.name}" ready (${Object.keys(integration.tools.tools).length} tools)`);
+            }
+            catch (err) {
+                logger.error(`User integration "${integration.name}" failed to initialize: ${err instanceof Error ? err.message : err} — skipping`);
+            }
+        }
+    }
+    static mcpSignature(server) {
+        const sortedEnv = Object.fromEntries(Object.entries(server.env ?? {}).sort(([a], [b]) => a.localeCompare(b)));
+        return JSON.stringify({
+            command: server.command ?? null,
+            args: server.args ?? [],
+            env: sortedEnv,
+            url: server.url ?? null,
+        });
+    }
+    /** Reconcile MCP integrations against config.mcpServers (add/update/remove). */
+    async refreshMcpIntegrations(config) {
+        const desiredNames = new Set(Object.keys(config.mcpServers));
+        const existingMcp = [...this.integrations.values()].filter((i) => i.source === "mcp");
+        // Remove deleted MCP servers.
+        for (const integration of existingMcp) {
+            if (desiredNames.has(integration.name))
+                continue;
+            if (integration.tools.cleanup) {
+                try {
+                    await integration.tools.cleanup();
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+            this.integrations.delete(integration.name);
+            this.mcpConfigSignatures.delete(integration.name);
+            logger.info(`MCP integration "${integration.name}" removed (config entry deleted)`);
+        }
+        // Add or update configured MCP servers.
+        for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+            const nextSignature = IntegrationRegistry.mcpSignature(serverConfig);
+            const prevSignature = this.mcpConfigSignatures.get(name);
+            const existing = this.integrations.get(name);
+            const unchangedMcp = existing?.source === "mcp" && prevSignature === nextSignature;
+            if (unchangedMcp)
+                continue;
+            if (existing?.source === "mcp") {
+                if (existing.tools.cleanup) {
+                    try {
+                        await existing.tools.cleanup();
+                    }
+                    catch {
+                        /* best-effort */
+                    }
+                }
+                this.integrations.delete(name);
+            }
+            try {
+                const integration = await createMcpIntegration(name, serverConfig);
+                await integration.tools.initialize();
+                this.register(integration);
+                this.recordMcpConfigSignature(name, serverConfig);
+                logger.info(`MCP integration "${name}" refreshed`);
+            }
+            catch (err) {
+                logger.error(`MCP server "${name}" failed to refresh: ${err instanceof Error ? err.message : err} — skipping`);
+            }
+        }
+    }
+    /** Build a compact listing of all available integrations for the system prompt. */
+    buildListing(active) {
+        if (this.integrations.size === 0)
+            return "";
+        const lines = [];
+        for (const [name, integration] of this.integrations) {
+            const toolNames = Object.keys(integration.tools.tools).join(", ");
+            const status = active?.has(name) ? " (enabled)" : " (disabled)";
+            const sourceTag = integration.source === "mcp" ? " [MCP]" :
+                integration.source === "user" ? " [user]" : "";
+            lines.push(`  - **${name}**${sourceTag}${status}: ${toolNames}`);
+        }
+        return `## Integrations
+Integrations provide external tools (APIs, MCP servers, services). Items marked [MCP] are connected MCP servers. Items marked [user] are user-defined integrations.
+You can enable or disable integrations mid-session using the \`enable_integration\` and \`disable_integration\` tools.
+When the user asks about integrations, MCP servers, or available tools, refer to this list.
+
+<available_integrations>
+${lines.join("\n")}
+</available_integrations>`;
+    }
+}
+/**
+ * Resolve config values for a builtin integration by reading flat keys
+ * from the ConfigStore via the integration's ConfigAdapter.configKeys mapping.
+ * Returns the assembled config object, or null if required keys are missing.
+ */
+function resolveBuiltinConfig(id, store) {
+    const factory = BUILTIN_FACTORIES[id];
+    if (!factory)
+        return null;
+    // Build a probe integration to extract ConfigAdapter metadata.
+    // This is cheap — the factory doesn't call external APIs until initialize().
+    const dummyConfig = getDummyConfig(id);
+    const probe = factory(dummyConfig);
+    if (!probe.config)
+        return null;
+    const data = store.load();
+    const assembled = {};
+    let hasRequired = false;
+    for (const [field, flatKey] of Object.entries(probe.config.configKeys)) {
+        const val = data[flatKey];
+        if (typeof val === "string" && val) {
+            assembled[field] = val;
+            hasRequired = true;
+        }
+    }
+    // Validate with the schema — if it fails, the required keys are missing
+    const result = probe.config.schema.safeParse(assembled);
+    if (!result.success) {
+        if (hasRequired) {
+            logger.warn(`Integration "${id}" config incomplete: ${result.error.message}`);
+        }
+        return null;
+    }
+    return assembled;
+}
+/** Minimal dummy config per integration id (never hits network). */
+function getDummyConfig(id) {
+    switch (id) {
+        case "github":
+            return { token: "dummy" };
+        case "twitter":
+            return { bearerToken: "dummy" };
+        default:
+            return {};
+    }
+}
+/**
+ * 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 async function loadIntegrations(config, store) {
+    const registry = new IntegrationRegistry();
+    const candidates = [];
+    // Auto-discover builtin integrations via ConfigAdapter
+    for (const [id, factory] of Object.entries(BUILTIN_FACTORIES)) {
+        const resolved = resolveBuiltinConfig(id, store);
+        if (resolved) {
+            candidates.push(factory(resolved));
+        }
+    }
+    // User integrations from directory
+    try {
+        const userIntegrations = await scanUserIntegrations(INTEGRATIONS_DIR, store);
+        candidates.push(...userIntegrations);
+    }
+    catch (err) {
+        logger.error(`User integration scan failed: ${err instanceof Error ? err.message : err}`);
+    }
+    // MCP servers (no ConfigAdapter — loaded from config.mcpServers)
+    for (const [name, serverConfig] of Object.entries(config.mcpServers)) {
+        try {
+            const integration = await createMcpIntegration(name, serverConfig);
+            candidates.push(integration);
+        }
+        catch (err) {
+            logger.error(`MCP server "${name}" failed to connect: ${err instanceof Error ? err.message : err} — skipping`);
+        }
+    }
+    for (const integration of candidates) {
+        try {
+            await integration.tools.initialize();
+            registry.register(integration);
+            if (integration.source === "mcp") {
+                const serverConfig = config.mcpServers[integration.name];
+                if (serverConfig)
+                    registry.recordMcpConfigSignature(integration.name, serverConfig);
+            }
+            logger.info(`Integration "${integration.name}" ready (${Object.keys(integration.tools.tools).length} tools)`);
+        }
+        catch (err) {
+            logger.error(`Integration "${integration.name}" failed to initialize: ${err instanceof Error ? err.message : err} — skipping`);
+        }
+    }
+    return registry;
+}

package/dist/integrations/scanner.d.ts

@@ -0,0 +1,10 @@
+import type { ConfigStore } from "../config/store.js";
+import type { Integration } from "./types.js";
+/**
+ * Scan a directory for user integration files, resolve their config
+ * from the ConfigStore, and return ready-to-register Integrations.
+ *
+ * Each file must default-export an IntegrationDefinition.
+ * Files whose required config keys are missing are silently skipped.
+ */
+export declare function scanUserIntegrations(dir: string, store: ConfigStore): Promise<Integration[]>;

package/dist/integrations/scanner.js

@@ -0,0 +1,122 @@
+import { readdir, stat } from "fs/promises";
+import { join, resolve } from "path";
+import { logger } from "../logger.js";
+/** File extensions we attempt to import as integration modules. */
+const IMPORTABLE_EXTENSIONS = new Set([".ts", ".js", ".mjs"]);
+/**
+ * Scan a directory for user integration files, resolve their config
+ * from the ConfigStore, and return ready-to-register Integrations.
+ *
+ * Each file must default-export an IntegrationDefinition.
+ * Files whose required config keys are missing are silently skipped.
+ */
+export async function scanUserIntegrations(dir, store) {
+    const absDir = resolve(dir);
+    let entries;
+    try {
+        entries = await readdir(absDir);
+    }
+    catch {
+        // Directory doesn't exist yet — not an error
+        return [];
+    }
+    const integrations = [];
+    const seenIds = new Set();
+    for (const entry of entries) {
+        const ext = entry.slice(entry.lastIndexOf("."));
+        if (!IMPORTABLE_EXTENSIONS.has(ext))
+            continue;
+        const filePath = join(absDir, entry);
+        const fileStat = await stat(filePath).catch(() => null);
+        if (!fileStat?.isFile())
+            continue;
+        try {
+            const integration = await loadUserIntegration(filePath, store);
+            if (!integration)
+                continue; // config keys not present — skip silently
+            if (seenIds.has(integration.id)) {
+                logger.warn(`Duplicate user integration id "${integration.id}" at ${filePath}, skipping`);
+                continue;
+            }
+            seenIds.add(integration.id);
+            integrations.push(integration);
+        }
+        catch (err) {
+            logger.error(`User integration "${entry}" failed to load: ${err instanceof Error ? err.message : err}`);
+        }
+    }
+    return integrations;
+}
+/**
+ * Import a single user integration file, resolve config, and return an Integration.
+ * Returns null if required config keys are missing.
+ */
+async function loadUserIntegration(filePath, store) {
+    // Dynamic import — Bun handles .ts natively
+    const mod = await import(filePath);
+    const def = mod.default ?? mod;
+    if (!def.id || typeof def.id !== "string") {
+        throw new Error("Missing or invalid 'id' (must be a non-empty string)");
+    }
+    if (!def.name || typeof def.name !== "string") {
+        throw new Error("Missing or invalid 'name' (must be a non-empty string)");
+    }
+    if (typeof def.create !== "function") {
+        throw new Error("Missing 'create' function");
+    }
+    // Resolve config from ConfigStore using configKeys mapping
+    const config = resolveConfig(def, store);
+    if (config === null)
+        return null;
+    const toolAdapter = await def.create(config);
+    // Validate the returned ToolAdapter shape
+    if (!toolAdapter || typeof toolAdapter !== "object") {
+        throw new Error("create() must return a ToolAdapter object");
+    }
+    if (!toolAdapter.tools || typeof toolAdapter.tools !== "object") {
+        throw new Error("create() returned ToolAdapter missing 'tools' (must be a ToolSet object)");
+    }
+    if (typeof toolAdapter.initialize !== "function") {
+        throw new Error("create() returned ToolAdapter missing 'initialize' (must be a function)");
+    }
+    return {
+        id: def.id,
+        name: def.name,
+        source: "user",
+        tools: toolAdapter,
+        config: def.configKeys
+            ? {
+                schema: def.configSchema ?? noopSchema,
+                configKeys: def.configKeys,
+            }
+            : undefined,
+    };
+}
+/**
+ * Resolve flat config keys from the ConfigStore into a config object.
+ * Returns null if validation fails (required keys missing).
+ */
+function resolveConfig(def, store) {
+    if (!def.configKeys)
+        return {};
+    const data = store.load();
+    const assembled = {};
+    for (const [field, flatKey] of Object.entries(def.configKeys)) {
+        const val = data[flatKey];
+        if (typeof val === "string" && val) {
+            assembled[field] = val;
+        }
+    }
+    // Validate with schema if provided
+    if (def.configSchema) {
+        const result = def.configSchema.safeParse(assembled);
+        if (!result.success)
+            return null;
+    }
+    return assembled;
+}
+/** Passthrough schema for integrations without configSchema. */
+const noopSchema = {
+    safeParse: (val) => ({ success: true, data: val }),
+    parse: (val) => val,
+};

package/dist/integrations/twitter.d.ts

@@ -0,0 +1,10 @@
+import type { Integration } from "./types.js";
+interface TwitterConfig {
+    bearerToken: string;
+    apiKey?: string;
+    apiSecret?: string;
+    accessToken?: string;
+    accessSecret?: string;
+}
+export declare function createTwitterIntegration(config: TwitterConfig): Integration;
+export {};

package/dist/integrations/twitter.js

@@ -0,0 +1,120 @@
+import { tool } from "ai";
+import { z } from "zod";
+import { TwitterApi } from "twitter-api-v2";
+import { logger } from "../logger.js";
+const MAX_TWEET_LENGTH = 280;
+const DEFAULT_SEARCH_LIMIT = 10;
+/** Zod schema for Twitter integration config. */
+const twitterConfigSchema = z.object({
+    bearerToken: z.string().min(1),
+    apiKey: z.string().optional(),
+    apiSecret: z.string().optional(),
+    accessToken: z.string().optional(),
+    accessSecret: z.string().optional(),
+});
+/** Flat config.json keys → TwitterConfig fields. */
+const TWITTER_CONFIG_KEYS = {
+    bearerToken: "TWITTER_BEARER_TOKEN",
+    apiKey: "TWITTER_API_KEY",
+    apiSecret: "TWITTER_API_SECRET",
+    accessToken: "TWITTER_ACCESS_TOKEN",
+    accessSecret: "TWITTER_ACCESS_SECRET",
+};
+export function createTwitterIntegration(config) {
+    // Read-only client (bearer token) for search
+    const readClient = new TwitterApi(config.bearerToken);
+    // Read-write client (OAuth 1.0a) for posting — only if credentials provided
+    const hasWriteAccess = config.apiKey && config.apiSecret && config.accessToken && config.accessSecret;
+    const writeClient = hasWriteAccess
+        ? new TwitterApi({
+            appKey: config.apiKey,
+            appSecret: config.apiSecret,
+            accessToken: config.accessToken,
+            accessSecret: config.accessSecret,
+        })
+        : null;
+    const tools = {
+        twitter_search: tool({
+            description: "Search for recent tweets matching a query",
+            inputSchema: z.object({
+                query: z.string().describe("Search query (Twitter search syntax)"),
+                limit: z
+                    .number()
+                    .optional()
+                    .describe(`Max results (default: ${DEFAULT_SEARCH_LIMIT}, max: 100)`),
+            }),
+            execute: async ({ query, limit }) => {
+                try {
+                    const result = await readClient.v2.search(query, {
+                        max_results: Math.min(limit ?? DEFAULT_SEARCH_LIMIT, 100),
+                        "tweet.fields": ["created_at", "author_id", "public_metrics"],
+                    });
+                    const tweets = result.data?.data;
+                    if (!tweets?.length)
+                        return "No tweets found.";
+                    return tweets
+                        .map((t) => {
+                        const metrics = t.public_metrics;
+                        const stats = metrics
+                            ? ` [${metrics.like_count} likes, ${metrics.retweet_count} RTs]`
+                            : "";
+                        return `@${t.author_id} (${t.created_at}): ${t.text}${stats}`;
+                    })
+                        .join("\n\n");
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    logger.error(`twitter_search failed: ${msg}`);
+                    return `Error searching tweets: ${msg}`;
+                }
+            },
+        }),
+    };
+    // Only register posting tool if write credentials are available
+    if (writeClient) {
+        tools.twitter_post = tool({
+            description: `Post a tweet to Twitter/X (max ${MAX_TWEET_LENGTH} characters)`,
+            inputSchema: z.object({
+                text: z
+                    .string()
+                    .max(MAX_TWEET_LENGTH)
+                    .describe(`Tweet text (max ${MAX_TWEET_LENGTH} characters)`),
+            }),
+            execute: async ({ text }) => {
+                try {
+                    const { data } = await writeClient.v2.tweet(text);
+                    return `Posted tweet: https://twitter.com/i/status/${data.id}`;
+                }
+                catch (err) {
+                    const msg = err instanceof Error ? err.message : String(err);
+                    logger.error(`twitter_post failed: ${msg}`);
+                    return `Error posting tweet: ${msg}`;
+                }
+            },
+        });
+    }
+    const toolNames = Object.keys(tools).join(", ");
+    return {
+        id: "twitter",
+        name: "twitter",
+        source: "builtin",
+        tools: {
+            tools,
+            systemPrompt: [
+                "## Twitter/X Integration",
+                `You have Twitter tools available: ${toolNames}.`,
+                "- `twitter_search`: Search recent tweets (last 7 days)",
+                writeClient ? "- `twitter_post`: Post a new tweet (max 280 characters)" : "",
+            ]
+                .filter(Boolean)
+                .join("\n"),
+            initialize: async () => {
+                logger.info(`Twitter integration ready (search: yes, post: ${writeClient ? "yes" : "no — missing OAuth credentials"})`);
+            },
+        },
+        config: {
+            schema: twitterConfigSchema,
+            configKeys: TWITTER_CONFIG_KEYS,
+        },
+    };
+}