@customclaw/composio 0.0.1 → 0.0.2

package/README.md

@@ -1,17 +1,6 @@
-# Composio Tool Router Plugin for OpenClaw
+# @customclaw/composio
 
-Access 1000+ third-party tools through Composio's unified Tool Router interface.
-
-## Features
-
-- **Search Tools**: Find tools by describing what you want to accomplish
-- **Execute Tools**: Run any tool with authenticated connections
-- **Multi-Execute**: Run up to 50 tools in parallel
-- **Connection Management**: Connect to toolkits via OAuth or API keys
-
-## Supported Integrations
-
-Gmail, Slack, GitHub, Notion, Linear, Jira, HubSpot, Salesforce, Google Drive, Asana, Trello, and 1000+ more.
+OpenClaw plugin that connects your agent to Gmail, Sentry, and other services through [Composio](https://composio.dev)'s Tool Router.
 
 ## Install
 
@@ -19,17 +8,11 @@ Gmail, Slack, GitHub, Notion, Linear, Jira, HubSpot, Salesforce, Google Drive, A
 openclaw plugins install @customclaw/composio
 ```
 
-## Configuration
-
-### Option 1: Environment Variable
-
-```bash
-export COMPOSIO_API_KEY=your-api-key
-```
+## Setup
 
-### Option 2: OpenClaw Config
+1. Get an API key from [platform.composio.dev/settings](https://platform.composio.dev/settings)
 
-Add to `~/.openclaw/openclaw.json`:
+2. Add to `~/.openclaw/openclaw.json`:
 
 ```json
 {
@@ -39,7 +22,6 @@ Add to `~/.openclaw/openclaw.json`:
         "enabled": true,
         "config": {
           "apiKey": "your-api-key",
-          "defaultUserId": "client-companyname-uuid",
           "allowedToolkits": ["gmail", "sentry"]
         }
       }
@@ -48,112 +30,36 @@ Add to `~/.openclaw/openclaw.json`:
 }
 ```
 
-Get your API key from [platform.composio.dev/settings](https://platform.composio.dev/settings).
+Or set `COMPOSIO_API_KEY` as an environment variable.
 
-## CLI Commands
+3. Restart the gateway.
 
-```bash
-# List available toolkits
-openclaw composio list
-
-# Check connection status
-openclaw composio status
-openclaw composio status github
-
-# Connect to a toolkit (opens auth URL)
-openclaw composio connect github
-openclaw composio connect gmail
-
-# Disconnect from a toolkit
-openclaw composio disconnect github
+## What it does
 
-# Search for tools
-openclaw composio search "send email"
-openclaw composio search "create issue" --toolkit github
-```
-
-## Agent Tools
+The plugin gives your agent two tools:
 
-The plugin provides six tools for agents:
+- `composio_execute_tool` — runs a Composio action (e.g. `GMAIL_FETCH_EMAILS`, `SENTRY_LIST_ISSUES`)
+- `composio_manage_connections` — checks connection status and generates OAuth links when a toolkit isn't connected yet
 
-### `composio_search_tools`
+The agent handles the rest. Ask it to "check my latest emails" and it will call the right tool, prompt you to connect Gmail if needed, and fetch the results.
 
-Search for tools matching a task description.
+## CLI
 
-```json
-{
-  "query": "send an email with attachment",
-  "toolkits": ["gmail"],
-  "limit": 5
-}
-```
-
-### `composio_execute_tool`
-
-Execute a single tool.
-
-```json
-{
-  "tool_slug": "GMAIL_SEND_EMAIL",
-  "arguments": {
-    "to": "user@example.com",
-    "subject": "Hello",
-    "body": "Message content"
-  }
-}
-```
-
-### `composio_multi_execute`
-
-Execute multiple tools in parallel (up to 50).
-
-```json
-{
-  "executions": [
-    { "tool_slug": "GITHUB_CREATE_ISSUE", "arguments": { "title": "Bug", "repo": "org/repo" } },
-    { "tool_slug": "SLACK_SEND_MESSAGE", "arguments": { "channel": "#dev", "text": "Issue created" } }
-  ]
-}
-```
-
-### `composio_manage_connections`
-
-Manage toolkit connections.
-
-```json
-{
-  "action": "status",
-  "toolkits": ["github", "gmail"]
-}
+```bash
+openclaw composio list                          # list available toolkits
+openclaw composio status                        # check what's connected
+openclaw composio connect gmail                 # open OAuth link
+openclaw composio disconnect gmail              # remove a connection
+openclaw composio search "send email"           # find tool slugs
 ```
 
-### `composio_workbench`
-
-Execute Python code in a remote Jupyter sandbox.
-
-### `composio_bash`
-
-Execute bash commands in a remote sandbox.
+## Config options
 
-## Advanced Configuration
-
-```json
-{
-  "plugins": {
-    "entries": {
-      "composio": {
-        "enabled": true,
-        "config": {
-          "apiKey": "your-api-key",
-          "defaultUserId": "user_123",
-          "allowedToolkits": ["github", "gmail", "slack"],
-          "blockedToolkits": ["dangerous-toolkit"]
-        }
-      }
-    }
-  }
-}
-```
+| Key | Description |
+|-----|-------------|
+| `apiKey` | Composio API key (required) |
+| `allowedToolkits` | Only allow these toolkits (e.g. `["gmail", "sentry"]`) |
+| `blockedToolkits` | Block specific toolkits |
 
 ## Updating
 
@@ -162,23 +68,16 @@ openclaw plugins update @customclaw/composio
 openclaw gateway restart
 ```
 
-Gateway restart is required after updates.
-
 ## Development
 
 ```bash
+git clone https://github.com/customclaw/composio.git
+cd composio
 npm install
 npm run build
-npm pack  # creates .tgz for local testing
-openclaw plugins install ./customclaw-composio-0.0.1.tgz
+npm test
 ```
 
 ## Acknowledgments
 
-This project is based on the Composio plugin from [openclaw-composio](https://github.com/ComposioHQ/openclaw-composio) by ComposioHQ. See [THIRD-PARTY-NOTICES](./THIRD-PARTY-NOTICES) for details.
-
-## Links
-
-- [Composio Documentation](https://docs.composio.dev)
-- [Tool Router Overview](https://docs.composio.dev/tool-router/overview)
-- [Composio Platform](https://platform.composio.dev)
+Based on the Composio plugin from [openclaw-composio](https://github.com/ComposioHQ/openclaw-composio) by ComposioHQ. See [THIRD-PARTY-NOTICES](./THIRD-PARTY-NOTICES).

package/dist/client.test.d.ts

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

package/dist/client.test.js

@@ -0,0 +1,145 @@
+import { describe, it, expect, vi } from "vitest";
+import { ComposioClient } from "./client.js";
+import { parseComposioConfig } from "./config.js";
+// Mock the Composio SDK
+vi.mock("@composio/core", () => ({
+    Composio: vi.fn().mockImplementation(() => ({
+        toolRouter: {
+            create: vi.fn().mockResolvedValue({
+                sessionId: "test-session-123",
+                tools: vi.fn().mockResolvedValue([]),
+                authorize: vi.fn().mockResolvedValue({ url: "https://connect.composio.dev/test" }),
+                toolkits: vi.fn().mockResolvedValue({
+                    items: [
+                        { slug: "gmail", name: "Gmail", connection: { isActive: true } },
+                        { slug: "sentry", name: "Sentry", connection: { isActive: false } },
+                        { slug: "github", name: "GitHub", connection: { isActive: true } },
+                    ],
+                }),
+                experimental: { assistivePrompt: "" },
+            }),
+        },
+        client: {
+            tools: {
+                execute: vi.fn().mockResolvedValue({
+                    successful: true,
+                    data: { results: [{ tool_slug: "GMAIL_FETCH_EMAILS", index: 0, response: { successful: true, data: { messages: [] } } }] },
+                }),
+            },
+        },
+        connectedAccounts: {
+            list: vi.fn().mockResolvedValue({ items: [] }),
+            delete: vi.fn().mockResolvedValue({}),
+        },
+    })),
+}));
+function makeClient(overrides) {
+    return new ComposioClient({
+        enabled: true,
+        apiKey: "test-key",
+        ...overrides,
+    });
+}
+describe("config parsing", () => {
+    it("reads apiKey from config object", () => {
+        const config = parseComposioConfig({ config: { apiKey: "from-config" } });
+        expect(config.apiKey).toBe("from-config");
+    });
+    it("reads apiKey from top-level", () => {
+        const config = parseComposioConfig({ apiKey: "from-top" });
+        expect(config.apiKey).toBe("from-top");
+    });
+    it("falls back to env var", () => {
+        process.env.COMPOSIO_API_KEY = "from-env";
+        const config = parseComposioConfig({});
+        expect(config.apiKey).toBe("from-env");
+        delete process.env.COMPOSIO_API_KEY;
+    });
+    it("defaults enabled to true", () => {
+        const config = parseComposioConfig({});
+        expect(config.enabled).toBe(true);
+    });
+});
+describe("toolkit filtering", () => {
+    it("allows all toolkits when no filter set", async () => {
+        const client = makeClient();
+        const statuses = await client.getConnectionStatus(["gmail", "sentry", "github"]);
+        expect(statuses).toHaveLength(3);
+    });
+    it("filters by allowedToolkits", async () => {
+        const client = makeClient({ allowedToolkits: ["gmail", "sentry"] });
+        const statuses = await client.getConnectionStatus(["gmail", "sentry", "github"]);
+        expect(statuses).toHaveLength(2);
+        expect(statuses.map(s => s.toolkit)).toEqual(["gmail", "sentry"]);
+    });
+    it("filters by blockedToolkits", async () => {
+        const client = makeClient({ blockedToolkits: ["github"] });
+        const statuses = await client.getConnectionStatus(["gmail", "sentry", "github"]);
+        expect(statuses).toHaveLength(2);
+        expect(statuses.find(s => s.toolkit === "github")).toBeUndefined();
+    });
+    it("blocked takes priority over allowed", async () => {
+        const client = makeClient({ allowedToolkits: ["gmail", "github"], blockedToolkits: ["github"] });
+        const statuses = await client.getConnectionStatus(["gmail", "github"]);
+        expect(statuses).toHaveLength(1);
+        expect(statuses[0].toolkit).toBe("gmail");
+    });
+});
+describe("connection status", () => {
+    it("reports gmail as connected", async () => {
+        const client = makeClient();
+        const statuses = await client.getConnectionStatus(["gmail"]);
+        expect(statuses[0].connected).toBe(true);
+    });
+    it("reports sentry as not connected", async () => {
+        const client = makeClient();
+        const statuses = await client.getConnectionStatus(["sentry"]);
+        expect(statuses[0].connected).toBe(false);
+    });
+    it("returns only connected toolkits when no filter", async () => {
+        const client = makeClient();
+        const statuses = await client.getConnectionStatus();
+        expect(statuses.every(s => s.connected)).toBe(true);
+        expect(statuses.map(s => s.toolkit)).toEqual(["gmail", "github"]);
+    });
+});
+describe("execute tool", () => {
+    it("executes and returns result", async () => {
+        const client = makeClient();
+        const result = await client.executeTool("GMAIL_FETCH_EMAILS", {});
+        expect(result.success).toBe(true);
+        expect(result.data).toEqual({ messages: [] });
+    });
+    it("rejects blocked toolkit", async () => {
+        const client = makeClient({ allowedToolkits: ["sentry"] });
+        const result = await client.executeTool("GMAIL_FETCH_EMAILS", {});
+        expect(result.success).toBe(false);
+        expect(result.error).toContain("not allowed");
+    });
+});
+describe("create connection", () => {
+    it("returns auth URL", async () => {
+        const client = makeClient();
+        const result = await client.createConnection("gmail");
+        expect("authUrl" in result).toBe(true);
+        if ("authUrl" in result) {
+            expect(result.authUrl).toContain("connect.composio.dev");
+        }
+    });
+    it("rejects blocked toolkit", async () => {
+        const client = makeClient({ blockedToolkits: ["gmail"] });
+        const result = await client.createConnection("gmail");
+        expect("error" in result).toBe(true);
+    });
+});
+describe("session caching", () => {
+    it("reuses session for same user", async () => {
+        const client = makeClient();
+        await client.getConnectionStatus(["gmail"]);
+        await client.getConnectionStatus(["gmail"]);
+        // toolRouter.create should only be called once
+        const { Composio } = await import("@composio/core");
+        const instance = Composio.mock.results[0].value;
+        expect(instance.toolRouter.create).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/index.js

@@ -1,11 +1,7 @@
 import { composioPluginConfigSchema, parseComposioConfig } from "./config.js";
 import { createComposioClient } from "./client.js";
-import { createComposioSearchTool } from "./tools/search.js";
 import { createComposioExecuteTool } from "./tools/execute.js";
-import { createComposioMultiExecuteTool } from "./tools/multi-execute.js";
 import { createComposioConnectionsTool } from "./tools/connections.js";
-import { createComposioWorkbenchTool } from "./tools/workbench.js";
-import { createCompositoBashTool } from "./tools/bash.js";
 import { registerComposioCli } from "./cli.js";
 /**
  * Composio Tool Router Plugin for OpenClaw
@@ -51,42 +47,18 @@ const composioPlugin = {
             return client;
         };
         // Register tools (lazily create client on first use)
-        api.registerTool({
-            ...createComposioSearchTool(ensureClient(), config),
-            execute: async (toolCallId, params) => {
-                return createComposioSearchTool(ensureClient(), config).execute(toolCallId, params);
-            },
-        });
         api.registerTool({
             ...createComposioExecuteTool(ensureClient(), config),
             execute: async (toolCallId, params) => {
                 return createComposioExecuteTool(ensureClient(), config).execute(toolCallId, params);
             },
         });
-        api.registerTool({
-            ...createComposioMultiExecuteTool(ensureClient(), config),
-            execute: async (toolCallId, params) => {
-                return createComposioMultiExecuteTool(ensureClient(), config).execute(toolCallId, params);
-            },
-        });
         api.registerTool({
             ...createComposioConnectionsTool(ensureClient(), config),
             execute: async (toolCallId, params) => {
                 return createComposioConnectionsTool(ensureClient(), config).execute(toolCallId, params);
             },
         });
-        api.registerTool({
-            ...createComposioWorkbenchTool(ensureClient(), config),
-            execute: async (toolCallId, params) => {
-                return createComposioWorkbenchTool(ensureClient(), config).execute(toolCallId, params);
-            },
-        });
-        api.registerTool({
-            ...createCompositoBashTool(ensureClient(), config),
-            execute: async (toolCallId, params) => {
-                return createCompositoBashTool(ensureClient(), config).execute(toolCallId, params);
-            },
-        });
         // Register CLI commands
         api.registerCli(({ program }) => registerComposioCli({
             program,
@@ -98,28 +70,21 @@ const composioPlugin = {
         api.on("before_agent_start", () => {
             return {
                 prependContext: `<composio-tools>
-You have access to Composio Tool Router, which provides 1000+ third-party integrations (Gmail, Slack, GitHub, Notion, Linear, Jira, HubSpot, Google Drive, etc.).
-
-## How to use Composio tools
-
-1. **Search first**: Use \`composio_search_tools\` to find tools matching the user's task. Search by describing what you want to do (e.g., "send email", "create github issue").
-
-2. **Check connections**: Before executing, use \`composio_manage_connections\` with action="status" to verify the required toolkit is connected. If not connected, use action="create" to generate an auth URL for the user.
+You have access to Composio tools for third-party integrations (Gmail, Sentry, etc.).
 
-3. **Execute tools**: Use \`composio_execute_tool\` with the tool_slug from search results and arguments matching the tool's schema. For multiple operations, use \`composio_multi_execute\` to run up to 50 tools in parallel.
+## Usage
+1. Use \`composio_manage_connections\` with action="status" to check if a toolkit is connected. Use action="create" to generate an auth URL if needed.
+2. Use \`composio_execute_tool\` with a tool_slug and arguments to execute actions.
 
-4. **Remote processing**: For large responses or bulk operations, use \`composio_workbench\` to run Python code in a remote Jupyter sandbox with helpers like run_composio_tool(), invoke_llm(), etc. Use \`composio_bash\` for shell commands in the remote sandbox.
+## Common tool slugs
+- GMAIL_FETCH_EMAILS, GMAIL_SEND_EMAIL, GMAIL_GET_PROFILE
+- SENTRY_LIST_ISSUES, SENTRY_GET_ISSUE
 
-## Important notes
-- Tool slugs are uppercase (e.g., GMAIL_SEND_EMAIL, GITHUB_CREATE_ISSUE)
-- Always use exact tool_slug values from search results - do not invent slugs
-- Check the parameters schema from search results before executing
-- If a tool fails with auth errors, prompt the user to connect the toolkit
-- Use workbench/bash tools when processing data stored in remote files or scripting bulk operations
+Tool slugs are uppercase. If a tool fails with auth errors, prompt the user to connect the toolkit.
 </composio-tools>`,
             };
         });
-        api.logger.info("[composio] Plugin registered with 6 tools and CLI commands");
+        api.logger.info("[composio] Plugin registered with 2 tools and CLI commands");
     },
 };
 export default composioPlugin;

package/package.json

@@ -1,15 +1,18 @@
 {
   "name": "@customclaw/composio",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "type": "module",
   "description": "Composio Tool Router plugin for OpenClaw — access 1000+ third-party integrations",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "openclaw": {
-    "extensions": ["./dist/index.js"]
+    "extensions": [
+      "./dist/index.js"
+    ]
   },
   "scripts": {
     "build": "tsc",
+    "test": "vitest run",
     "prepublishOnly": "npm run build"
   },
   "files": [
@@ -25,12 +28,13 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@composio/core": "^0.5.5",
+    "@composio/core": "^0.6.3",
     "@sinclair/typebox": "0.34.47",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/node": "^25.2.3",
-    "typescript": "^5.4.0"
+    "typescript": "^5.4.0",
+    "vitest": "^3.2.4"
   }
 }