@customclaw/composio 0.0.1

package/dist/client.js

@@ -0,0 +1,386 @@
+import { Composio } from "@composio/core";
+/**
+ * Composio client wrapper using Tool Router pattern
+ */
+export class ComposioClient {
+    client;
+    config;
+    sessionCache = new Map();
+    constructor(config) {
+        if (!config.apiKey) {
+            throw new Error("Composio API key required. Set COMPOSIO_API_KEY env var or plugins.composio.apiKey in config.");
+        }
+        this.config = config;
+        this.client = new Composio({ apiKey: config.apiKey });
+    }
+    /**
+     * Get the user ID to use for API calls
+     */
+    getUserId(overrideUserId) {
+        return overrideUserId || this.config.defaultUserId || "default";
+    }
+    /**
+     * Get or create a Tool Router session for a user
+     */
+    async getSession(userId) {
+        if (this.sessionCache.has(userId)) {
+            return this.sessionCache.get(userId);
+        }
+        const session = await this.client.toolRouter.create(userId);
+        this.sessionCache.set(userId, session);
+        return session;
+    }
+    /**
+     * Check if a toolkit is allowed based on config
+     */
+    isToolkitAllowed(toolkit) {
+        const { allowedToolkits, blockedToolkits } = this.config;
+        if (blockedToolkits?.includes(toolkit.toLowerCase())) {
+            return false;
+        }
+        if (allowedToolkits && allowedToolkits.length > 0) {
+            return allowedToolkits.includes(toolkit.toLowerCase());
+        }
+        return true;
+    }
+    /**
+     * Execute a Tool Router meta-tool
+     */
+    async executeMetaTool(toolName, args) {
+        const response = await this.client.client.tools.execute(toolName, {
+            arguments: args,
+        });
+        return response;
+    }
+    /**
+     * Search for tools matching a query using COMPOSIO_SEARCH_TOOLS
+     */
+    async searchTools(query, options) {
+        const userId = this.getUserId(options?.userId);
+        const session = await this.getSession(userId);
+        try {
+            const response = await this.executeMetaTool("COMPOSIO_SEARCH_TOOLS", {
+                queries: [{ use_case: query }],
+                session: { id: session.sessionId },
+            });
+            if (!response.successful || !response.data) {
+                throw new Error(response.error || "Search failed");
+            }
+            const data = response.data;
+            const searchResults = data.results || [];
+            const toolSchemas = data.tool_schemas || {};
+            const results = [];
+            const seenSlugs = new Set();
+            for (const result of searchResults) {
+                const allSlugs = [
+                    ...(result.primary_tool_slugs || []),
+                    ...(result.related_tool_slugs || []),
+                ];
+                for (const slug of allSlugs) {
+                    if (seenSlugs.has(slug))
+                        continue;
+                    seenSlugs.add(slug);
+                    const schema = toolSchemas[slug];
+                    const toolkit = schema?.toolkit || slug.split("_")[0] || "";
+                    if (!this.isToolkitAllowed(toolkit))
+                        continue;
+                    if (options?.toolkits && options.toolkits.length > 0) {
+                        if (!options.toolkits.some(t => t.toLowerCase() === toolkit.toLowerCase())) {
+                            continue;
+                        }
+                    }
+                    results.push({
+                        name: slug,
+                        slug: slug,
+                        description: schema?.description || "",
+                        toolkit: toolkit,
+                        parameters: schema?.input_schema || {},
+                    });
+                    if (options?.limit && results.length >= options.limit)
+                        break;
+                }
+                if (options?.limit && results.length >= options.limit)
+                    break;
+            }
+            return results;
+        }
+        catch (err) {
+            throw new Error(`Failed to search tools: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /**
+     * Execute a single tool using COMPOSIO_MULTI_EXECUTE_TOOL
+     */
+    async executeTool(toolSlug, args, userId) {
+        const uid = this.getUserId(userId);
+        const session = await this.getSession(uid);
+        const toolkit = toolSlug.split("_")[0]?.toLowerCase() || "";
+        if (!this.isToolkitAllowed(toolkit)) {
+            return {
+                success: false,
+                error: `Toolkit '${toolkit}' is not allowed by plugin configuration`,
+            };
+        }
+        try {
+            const response = await this.executeMetaTool("COMPOSIO_MULTI_EXECUTE_TOOL", {
+                tools: [{ tool_slug: toolSlug, arguments: args }],
+                session: { id: session.sessionId },
+                sync_response_to_workbench: false,
+            });
+            if (!response.successful) {
+                return { success: false, error: response.error || "Execution failed" };
+            }
+            const results = response.data?.results || [];
+            const result = results[0];
+            if (!result) {
+                return { success: false, error: "No result returned" };
+            }
+            // Response data is nested under result.response
+            const toolResponse = result.response;
+            return {
+                success: toolResponse.successful,
+                data: toolResponse.data,
+                error: toolResponse.error ?? undefined,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    /**
+     * Execute multiple tools in parallel using COMPOSIO_MULTI_EXECUTE_TOOL
+     */
+    async multiExecute(executions, userId) {
+        const uid = this.getUserId(userId);
+        const session = await this.getSession(uid);
+        // Filter out blocked toolkits and limit to 50
+        const allowedExecutions = executions
+            .filter(exec => {
+            const toolkit = exec.tool_slug.split("_")[0]?.toLowerCase() || "";
+            return this.isToolkitAllowed(toolkit);
+        })
+            .slice(0, 50);
+        if (allowedExecutions.length === 0) {
+            return { results: [] };
+        }
+        try {
+            const response = await this.executeMetaTool("COMPOSIO_MULTI_EXECUTE_TOOL", {
+                tools: allowedExecutions.map(exec => ({
+                    tool_slug: exec.tool_slug,
+                    arguments: exec.arguments,
+                })),
+                session: { id: session.sessionId },
+                sync_response_to_workbench: false,
+            });
+            if (!response.successful) {
+                return {
+                    results: allowedExecutions.map(exec => ({
+                        tool_slug: exec.tool_slug,
+                        success: false,
+                        error: response.error || "Execution failed",
+                    })),
+                };
+            }
+            const apiResults = response.data?.results || [];
+            return {
+                results: apiResults.map(r => ({
+                    tool_slug: r.tool_slug,
+                    success: r.response.successful,
+                    data: r.response.data,
+                    error: r.response.error ?? undefined,
+                })),
+            };
+        }
+        catch (err) {
+            return {
+                results: allowedExecutions.map(exec => ({
+                    tool_slug: exec.tool_slug,
+                    success: false,
+                    error: err instanceof Error ? err.message : String(err),
+                })),
+            };
+        }
+    }
+    /**
+     * Get connection status for toolkits using session.toolkits()
+     */
+    async getConnectionStatus(toolkits, userId) {
+        const uid = this.getUserId(userId);
+        const session = await this.getSession(uid);
+        try {
+            const response = await session.toolkits();
+            const allToolkits = response.items || [];
+            const statuses = [];
+            if (toolkits && toolkits.length > 0) {
+                // Check specific toolkits
+                for (const toolkit of toolkits) {
+                    if (!this.isToolkitAllowed(toolkit))
+                        continue;
+                    const found = allToolkits.find(t => t.slug.toLowerCase() === toolkit.toLowerCase());
+                    statuses.push({
+                        toolkit,
+                        connected: found?.connection?.isActive ?? false,
+                        userId: uid,
+                    });
+                }
+            }
+            else {
+                // Return all connected toolkits
+                for (const tk of allToolkits) {
+                    if (!this.isToolkitAllowed(tk.slug))
+                        continue;
+                    if (!tk.connection?.isActive)
+                        continue;
+                    statuses.push({
+                        toolkit: tk.slug,
+                        connected: true,
+                        userId: uid,
+                    });
+                }
+            }
+            return statuses;
+        }
+        catch (err) {
+            throw new Error(`Failed to get connection status: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    /**
+     * Create an auth connection for a toolkit using session.authorize()
+     */
+    async createConnection(toolkit, userId) {
+        const uid = this.getUserId(userId);
+        if (!this.isToolkitAllowed(toolkit)) {
+            return { error: `Toolkit '${toolkit}' is not allowed by plugin configuration` };
+        }
+        try {
+            const session = await this.getSession(uid);
+            const result = await session.authorize(toolkit);
+            return { authUrl: result.redirectUrl || result.url || "" };
+        }
+        catch (err) {
+            return {
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    /**
+     * List available toolkits
+     */
+    async listToolkits(userId) {
+        const uid = this.getUserId(userId);
+        try {
+            const session = await this.getSession(uid);
+            const response = await session.toolkits();
+            const allToolkits = response.items || [];
+            return allToolkits
+                .map(tk => tk.slug)
+                .filter(slug => this.isToolkitAllowed(slug));
+        }
+        catch (err) {
+            const errObj = err;
+            if (errObj?.status === 401) {
+                throw new Error("Invalid Composio API key. Get a valid key from platform.composio.dev/settings");
+            }
+            const apiMsg = errObj?.error?.error?.message;
+            throw new Error(`Failed to list toolkits: ${apiMsg || (err instanceof Error ? err.message : String(err))}`);
+        }
+    }
+    /**
+     * Disconnect a toolkit
+     */
+    async disconnectToolkit(toolkit, userId) {
+        const uid = this.getUserId(userId);
+        try {
+            const response = await this.client.connectedAccounts.list({ userId: uid });
+            const connections = (Array.isArray(response)
+                ? response
+                : response?.items || []);
+            const conn = connections.find(c => c.toolkit?.slug?.toLowerCase() === toolkit.toLowerCase());
+            if (!conn) {
+                return { success: false, error: `No connection found for toolkit '${toolkit}'` };
+            }
+            await this.client.connectedAccounts.delete({ connectedAccountId: conn.id });
+            // Clear session cache to refresh connection status
+            this.sessionCache.delete(uid);
+            return { success: true };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    /**
+     * Get the assistive prompt for the agent
+     */
+    async getAssistivePrompt(userId) {
+        const uid = this.getUserId(userId);
+        const session = await this.getSession(uid);
+        return session.experimental.assistivePrompt;
+    }
+    /**
+     * Execute Python code in the remote workbench using COMPOSIO_REMOTE_WORKBENCH
+     */
+    async executeWorkbench(code, options) {
+        const uid = this.getUserId(options?.userId);
+        const session = await this.getSession(uid);
+        try {
+            const response = await this.executeMetaTool("COMPOSIO_REMOTE_WORKBENCH", {
+                code_to_execute: code,
+                session_id: session.sessionId,
+                ...(options?.thought ? { thought: options.thought } : {}),
+                ...(options?.currentStep ? { current_step: options.currentStep } : {}),
+                ...(options?.currentStepMetric ? { current_step_metric: options.currentStepMetric } : {}),
+            });
+            if (!response.successful) {
+                return { success: false, error: response.error || "Workbench execution failed" };
+            }
+            return {
+                success: true,
+                output: response.data,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+    /**
+     * Execute bash commands in the remote sandbox using COMPOSIO_REMOTE_BASH_TOOL
+     */
+    async executeBash(command, userId) {
+        const uid = this.getUserId(userId);
+        const session = await this.getSession(uid);
+        try {
+            const response = await this.executeMetaTool("COMPOSIO_REMOTE_BASH_TOOL", {
+                command,
+                session_id: session.sessionId,
+            });
+            if (!response.successful) {
+                return { success: false, error: response.error || "Bash execution failed" };
+            }
+            return {
+                success: true,
+                output: response.data,
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: err instanceof Error ? err.message : String(err),
+            };
+        }
+    }
+}
+/**
+ * Create a Composio client instance
+ */
+export function createComposioClient(config) {
+    return new ComposioClient(config);
+}

package/dist/config.d.ts

@@ -0,0 +1,75 @@
+import { z } from "zod";
+import type { ComposioConfig } from "./types.js";
+/**
+ * Zod schema for Composio plugin configuration
+ */
+export declare const ComposioConfigSchema: z.ZodObject<{
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    apiKey: z.ZodOptional<z.ZodString>;
+    defaultUserId: z.ZodOptional<z.ZodString>;
+    allowedToolkits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    blockedToolkits: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+/**
+ * Parse and validate plugin config with environment fallbacks
+ */
+export declare function parseComposioConfig(value: unknown): ComposioConfig;
+/**
+ * UI hints for configuration fields
+ */
+export declare const composioConfigUiHints: {
+    enabled: {
+        label: string;
+        help: string;
+    };
+    apiKey: {
+        label: string;
+        help: string;
+        sensitive: boolean;
+    };
+    defaultUserId: {
+        label: string;
+        help: string;
+    };
+    allowedToolkits: {
+        label: string;
+        help: string;
+        advanced: boolean;
+    };
+    blockedToolkits: {
+        label: string;
+        help: string;
+        advanced: boolean;
+    };
+};
+/**
+ * Plugin config schema object for openclaw
+ */
+export declare const composioPluginConfigSchema: {
+    parse: typeof parseComposioConfig;
+    uiHints: {
+        enabled: {
+            label: string;
+            help: string;
+        };
+        apiKey: {
+            label: string;
+            help: string;
+            sensitive: boolean;
+        };
+        defaultUserId: {
+            label: string;
+            help: string;
+        };
+        allowedToolkits: {
+            label: string;
+            help: string;
+            advanced: boolean;
+        };
+        blockedToolkits: {
+            label: string;
+            help: string;
+            advanced: boolean;
+        };
+    };
+};

package/dist/config.js

@@ -0,0 +1,64 @@
+import { z } from "zod";
+/**
+ * Zod schema for Composio plugin configuration
+ */
+export const ComposioConfigSchema = z.object({
+    enabled: z.boolean().default(true),
+    apiKey: z.string().optional(),
+    defaultUserId: z.string().optional(),
+    allowedToolkits: z.array(z.string()).optional(),
+    blockedToolkits: z.array(z.string()).optional(),
+});
+/**
+ * Parse and validate plugin config with environment fallbacks
+ */
+export function parseComposioConfig(value) {
+    const raw = value && typeof value === "object" && !Array.isArray(value)
+        ? value
+        : {};
+    // Allow API key from config.apiKey, top-level apiKey, or environment
+    const configObj = raw.config;
+    const apiKey = (typeof configObj?.apiKey === "string" && configObj.apiKey.trim()) ||
+        (typeof raw.apiKey === "string" && raw.apiKey.trim()) ||
+        process.env.COMPOSIO_API_KEY ||
+        "";
+    return ComposioConfigSchema.parse({
+        ...raw,
+        apiKey,
+    });
+}
+/**
+ * UI hints for configuration fields
+ */
+export const composioConfigUiHints = {
+    enabled: {
+        label: "Enable Composio",
+        help: "Enable or disable the Composio Tool Router integration",
+    },
+    apiKey: {
+        label: "API Key",
+        help: "Composio API key from platform.composio.dev/settings",
+        sensitive: true,
+    },
+    defaultUserId: {
+        label: "Default User ID",
+        help: "Default user ID for session scoping (optional)",
+    },
+    allowedToolkits: {
+        label: "Allowed Toolkits",
+        help: "Restrict to specific toolkits (e.g., github, gmail)",
+        advanced: true,
+    },
+    blockedToolkits: {
+        label: "Blocked Toolkits",
+        help: "Block specific toolkits from being used",
+        advanced: true,
+    },
+};
+/**
+ * Plugin config schema object for openclaw
+ */
+export const composioPluginConfigSchema = {
+    parse: parseComposioConfig,
+    uiHints: composioConfigUiHints,
+};

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+import { parseComposioConfig } from "./config.js";
+/**
+ * Composio Tool Router Plugin for OpenClaw
+ *
+ * Provides access to 1000+ third-party tools through Composio's unified interface.
+ * Tools include: Gmail, Slack, GitHub, Notion, Linear, Jira, and many more.
+ *
+ * Configuration (in openclaw config):
+ * ```json
+ * {
+ *   "plugins": {
+ *     "composio": {
+ *       "enabled": true,
+ *       "apiKey": "your-composio-api-key"
+ *     }
+ *   }
+ * }
+ * ```
+ *
+ * Or set COMPOSIO_API_KEY environment variable.
+ */
+declare const composioPlugin: {
+    id: string;
+    name: string;
+    description: string;
+    configSchema: {
+        parse: typeof parseComposioConfig;
+        uiHints: {
+            enabled: {
+                label: string;
+                help: string;
+            };
+            apiKey: {
+                label: string;
+                help: string;
+                sensitive: boolean;
+            };
+            defaultUserId: {
+                label: string;
+                help: string;
+            };
+            allowedToolkits: {
+                label: string;
+                help: string;
+                advanced: boolean;
+            };
+            blockedToolkits: {
+                label: string;
+                help: string;
+                advanced: boolean;
+            };
+        };
+    };
+    register(api: any): void;
+};
+export default composioPlugin;