@customclaw/composio 0.0.7 → 0.0.9

package/dist/config.js

@@ -1,4 +1,5 @@
 import { z } from "zod";
+import { LEGACY_ENTRY_FLAT_CONFIG_KEYS, LEGACY_SHAPE_ERROR, SESSION_TAGS, isRecord, normalizeSessionTags, normalizeToolkitList, normalizeToolSlugList, } from "./utils.js";
 /**
  * Zod schema for Composio plugin configuration
  */
@@ -8,36 +9,39 @@ export const ComposioConfigSchema = z.object({
     defaultUserId: z.string().optional(),
     allowedToolkits: z.array(z.string()).optional(),
     blockedToolkits: z.array(z.string()).optional(),
+    readOnlyMode: z.boolean().default(false),
+    sessionTags: z.array(z.enum(SESSION_TAGS)).optional(),
+    allowedToolSlugs: z.array(z.string()).optional(),
+    blockedToolSlugs: 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
-        : {};
-    // Support both plugin entry shape ({ enabled, config: {...} }) and flat shape.
-    const configObj = raw.config;
-    const enabled = (typeof raw.enabled === "boolean" ? raw.enabled : undefined) ??
-        (typeof configObj?.enabled === "boolean" ? configObj.enabled : undefined) ??
-        true;
-    const defaultUserId = (typeof raw.defaultUserId === "string" ? raw.defaultUserId : undefined) ??
-        (typeof configObj?.defaultUserId === "string" ? configObj.defaultUserId : undefined);
-    const allowedToolkits = (Array.isArray(raw.allowedToolkits) ? raw.allowedToolkits : undefined) ??
-        (Array.isArray(configObj?.allowedToolkits) ? configObj.allowedToolkits : undefined);
-    const blockedToolkits = (Array.isArray(raw.blockedToolkits) ? raw.blockedToolkits : undefined) ??
-        (Array.isArray(configObj?.blockedToolkits) ? configObj.blockedToolkits : undefined);
-    // Allow API key from config.apiKey, top-level apiKey, or environment.
-    const apiKey = (typeof configObj?.apiKey === "string" && configObj.apiKey.trim()) ||
-        (typeof raw.apiKey === "string" && raw.apiKey.trim()) ||
+    const raw = isRecord(value) ? value : {};
+    const configObj = isRecord(raw.config) ? raw.config : undefined;
+    if (configObj) {
+        const hasLegacyFlatKeys = LEGACY_ENTRY_FLAT_CONFIG_KEYS.some((key) => key in raw);
+        if (hasLegacyFlatKeys) {
+            throw new Error(LEGACY_SHAPE_ERROR);
+        }
+    }
+    const source = configObj ?? raw;
+    const enabled = typeof raw.enabled === "boolean" ? raw.enabled : true;
+    const readOnlyMode = typeof source.readOnlyMode === "boolean" ? source.readOnlyMode : false;
+    const apiKey = (typeof source.apiKey === "string" && source.apiKey.trim()) ||
         process.env.COMPOSIO_API_KEY ||
         "";
     return ComposioConfigSchema.parse({
         enabled,
         apiKey,
-        defaultUserId,
-        allowedToolkits,
-        blockedToolkits,
+        defaultUserId: typeof source.defaultUserId === "string" ? source.defaultUserId : undefined,
+        allowedToolkits: normalizeToolkitList(Array.isArray(source.allowedToolkits) ? source.allowedToolkits : undefined),
+        blockedToolkits: normalizeToolkitList(Array.isArray(source.blockedToolkits) ? source.blockedToolkits : undefined),
+        readOnlyMode,
+        sessionTags: normalizeSessionTags(Array.isArray(source.sessionTags) ? source.sessionTags : undefined),
+        allowedToolSlugs: normalizeToolSlugList(Array.isArray(source.allowedToolSlugs) ? source.allowedToolSlugs : undefined),
+        blockedToolSlugs: normalizeToolSlugList(Array.isArray(source.blockedToolSlugs) ? source.blockedToolSlugs : undefined),
     });
 }
 /**
@@ -67,6 +71,26 @@ export const composioConfigUiHints = {
         help: "Block specific toolkits from being used",
         advanced: true,
     },
+    readOnlyMode: {
+        label: "Read-Only Mode",
+        help: "Block likely-destructive tool actions by token matching; allow specific slugs with allowedToolSlugs if needed",
+        advanced: true,
+    },
+    sessionTags: {
+        label: "Session Tags",
+        help: "Composio Tool Router behavior tags (e.g., readOnlyHint, destructiveHint)",
+        advanced: true,
+    },
+    allowedToolSlugs: {
+        label: "Allowed Tool Slugs",
+        help: "Optional explicit allowlist for tool slugs (UPPERCASE)",
+        advanced: true,
+    },
+    blockedToolSlugs: {
+        label: "Blocked Tool Slugs",
+        help: "Explicit denylist for tool slugs (UPPERCASE)",
+        advanced: true,
+    },
 };
 /**
  * Plugin config schema object for openclaw

package/dist/index.d.ts

@@ -49,6 +49,26 @@ declare const composioPlugin: {
                 help: string;
                 advanced: boolean;
             };
+            readOnlyMode: {
+                label: string;
+                help: string;
+                advanced: boolean;
+            };
+            sessionTags: {
+                label: string;
+                help: string;
+                advanced: boolean;
+            };
+            allowedToolSlugs: {
+                label: string;
+                help: string;
+                advanced: boolean;
+            };
+            blockedToolSlugs: {
+                label: string;
+                help: string;
+                advanced: boolean;
+            };
         };
     };
     register(api: any): void;

package/dist/index.js

@@ -4,6 +4,7 @@ import { createComposioSearchTool } from "./tools/search.js";
 import { createComposioExecuteTool } from "./tools/execute.js";
 import { createComposioConnectionsTool } from "./tools/connections.js";
 import { registerComposioCli } from "./cli.js";
+import { LEGACY_SHAPE_ERROR, hasLegacyFlatEntryConfig } from "./utils.js";
 /**
  * Composio Tool Router Plugin for OpenClaw
  *
@@ -31,7 +32,27 @@ const composioPlugin = {
         "Search, authenticate, and execute tools for Gmail, Slack, GitHub, Notion, and more.",
     configSchema: composioPluginConfigSchema,
     register(api) {
+        if (hasLegacyFlatEntryConfig(api?.config)) {
+            throw new Error(LEGACY_SHAPE_ERROR);
+        }
         const config = parseComposioConfig(api.pluginConfig);
+        let client = null;
+        const ensureClient = () => {
+            if (!config.apiKey) {
+                throw new Error("Composio API key required. Run 'openclaw composio setup' or set COMPOSIO_API_KEY.");
+            }
+            if (!client) {
+                client = createComposioClient(config);
+            }
+            return client;
+        };
+        // Register CLI commands even without API key so setup/status tooling remains available.
+        api.registerCli(({ program }) => registerComposioCli({
+            program,
+            getClient: config.apiKey ? ensureClient : undefined,
+            config,
+            logger: api.logger,
+        }), { commands: ["composio"] });
         if (!config.enabled) {
             api.logger.debug("[composio] Plugin disabled in config");
             return;
@@ -40,13 +61,6 @@ const composioPlugin = {
             api.logger.warn("[composio] No API key configured. Set COMPOSIO_API_KEY env var or plugins.composio.apiKey in config.");
             return;
         }
-        let client = null;
-        const ensureClient = () => {
-            if (!client) {
-                client = createComposioClient(config);
-            }
-            return client;
-        };
         // Register tools (lazily create client on first use)
         api.registerTool({
             ...createComposioSearchTool(ensureClient(), config),
@@ -66,13 +80,6 @@ const composioPlugin = {
                 return createComposioConnectionsTool(ensureClient(), config).execute(toolCallId, params);
             },
         });
-        // Register CLI commands
-        api.registerCli(({ program }) => registerComposioCli({
-            program,
-            client: ensureClient(),
-            config,
-            logger: api.logger,
-        }), { commands: ["composio"] });
         api.logger.info("[composio] Plugin registered with 3 tools and CLI commands");
     },
 };

package/dist/types.d.ts

@@ -1,12 +1,17 @@
 /**
  * Composio Tool Router types for OpenClaw integration
  */
+export type ComposioSessionTag = "readOnlyHint" | "destructiveHint" | "idempotentHint" | "openWorldHint";
 export interface ComposioConfig {
     enabled: boolean;
     apiKey?: string;
     defaultUserId?: string;
     allowedToolkits?: string[];
     blockedToolkits?: string[];
+    readOnlyMode?: boolean;
+    sessionTags?: ComposioSessionTag[];
+    allowedToolSlugs?: string[];
+    blockedToolSlugs?: string[];
 }
 export interface ToolSearchResult {
     name: string;

package/dist/utils.d.ts

@@ -0,0 +1,12 @@
+import type { ComposioSessionTag } from "./types.js";
+export declare const SESSION_TAGS: readonly ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"];
+export declare const LEGACY_ENTRY_FLAT_CONFIG_KEYS: readonly ["apiKey", "defaultUserId", "allowedToolkits", "blockedToolkits", "readOnlyMode", "sessionTags", "allowedToolSlugs", "blockedToolSlugs"];
+export declare const LEGACY_SHAPE_ERROR = "Legacy Composio config shape detected. Run 'openclaw composio setup'.";
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function normalizeToolkitSlug(value: unknown): string;
+export declare function normalizeToolSlug(value: unknown): string;
+export declare function normalizeToolkitList(values?: readonly unknown[]): string[] | undefined;
+export declare function normalizeToolSlugList(values?: readonly unknown[]): string[] | undefined;
+export declare function normalizeSessionTags(values?: readonly unknown[]): ComposioSessionTag[] | undefined;
+export declare function hasLegacyFlatEntryConfig(config: unknown): boolean;
+export declare function stripLegacyFlatConfigKeys(entry: Record<string, unknown>): Record<string, unknown>;

package/dist/utils.js

@@ -0,0 +1,76 @@
+export const SESSION_TAGS = [
+    "readOnlyHint",
+    "destructiveHint",
+    "idempotentHint",
+    "openWorldHint",
+];
+export const LEGACY_ENTRY_FLAT_CONFIG_KEYS = [
+    "apiKey",
+    "defaultUserId",
+    "allowedToolkits",
+    "blockedToolkits",
+    "readOnlyMode",
+    "sessionTags",
+    "allowedToolSlugs",
+    "blockedToolSlugs",
+];
+export const LEGACY_SHAPE_ERROR = "Legacy Composio config shape detected. Run 'openclaw composio setup'.";
+const SESSION_TAG_SET = new Set(SESSION_TAGS);
+export function isRecord(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+export function normalizeToolkitSlug(value) {
+    return String(value ?? "").trim().toLowerCase();
+}
+export function normalizeToolSlug(value) {
+    return String(value ?? "").trim().toUpperCase();
+}
+export function normalizeToolkitList(values) {
+    if (!values || values.length === 0)
+        return undefined;
+    const normalized = values
+        .filter((item) => typeof item === "string")
+        .map((item) => normalizeToolkitSlug(item))
+        .filter(Boolean);
+    if (normalized.length === 0)
+        return undefined;
+    return Array.from(new Set(normalized));
+}
+export function normalizeToolSlugList(values) {
+    if (!values || values.length === 0)
+        return undefined;
+    const normalized = values
+        .filter((item) => typeof item === "string")
+        .map((item) => normalizeToolSlug(item))
+        .filter(Boolean);
+    if (normalized.length === 0)
+        return undefined;
+    return Array.from(new Set(normalized));
+}
+export function normalizeSessionTags(values) {
+    if (!values || values.length === 0)
+        return undefined;
+    const normalized = values
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter((item) => SESSION_TAG_SET.has(item));
+    if (normalized.length === 0)
+        return undefined;
+    return Array.from(new Set(normalized));
+}
+export function hasLegacyFlatEntryConfig(config) {
+    const root = isRecord(config) ? config : undefined;
+    const plugins = isRecord(root?.plugins) ? root.plugins : undefined;
+    const entries = isRecord(plugins?.entries) ? plugins.entries : undefined;
+    const composioEntry = isRecord(entries?.composio) ? entries.composio : undefined;
+    if (!composioEntry)
+        return false;
+    return LEGACY_ENTRY_FLAT_CONFIG_KEYS.some((key) => key in composioEntry);
+}
+export function stripLegacyFlatConfigKeys(entry) {
+    const sanitized = { ...entry };
+    for (const key of LEGACY_ENTRY_FLAT_CONFIG_KEYS) {
+        delete sanitized[key];
+    }
+    return sanitized;
+}

package/openclaw.plugin.json

@@ -27,6 +27,25 @@
         "type": "array",
         "items": { "type": "string" },
         "description": "Block specific toolkits"
+      },
+      "readOnlyMode": {
+        "type": "boolean",
+        "description": "Block likely destructive tool actions by default"
+      },
+      "sessionTags": {
+        "type": "array",
+        "items": { "type": "string", "enum": ["readOnlyHint", "destructiveHint", "idempotentHint", "openWorldHint"] },
+        "description": "Optional Tool Router behavior tags"
+      },
+      "allowedToolSlugs": {
+        "type": "array",
+        "items": { "type": "string" },
+        "description": "Optional explicit allowlist for tool slugs (UPPERCASE)"
+      },
+      "blockedToolSlugs": {
+        "type": "array",
+        "items": { "type": "string" },
+        "description": "Explicit denylist for tool slugs (UPPERCASE)"
       }
     }
   },
@@ -53,6 +72,26 @@
       "label": "Blocked Toolkits",
       "help": "Block specific toolkits from being used",
       "advanced": true
+    },
+    "readOnlyMode": {
+      "label": "Read-Only Mode",
+      "help": "Block likely-destructive tool actions by default",
+      "advanced": true
+    },
+    "sessionTags": {
+      "label": "Session Tags",
+      "help": "Tool Router behavior tags (e.g., readOnlyHint, destructiveHint)",
+      "advanced": true
+    },
+    "allowedToolSlugs": {
+      "label": "Allowed Tool Slugs",
+      "help": "Optional explicit allowlist for tool slugs (UPPERCASE)",
+      "advanced": true
+    },
+    "blockedToolSlugs": {
+      "label": "Blocked Tool Slugs",
+      "help": "Explicit denylist for tool slugs (UPPERCASE)",
+      "advanced": true
     }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@customclaw/composio",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "type": "module",
   "description": "Composio Tool Router plugin for OpenClaw — access 1000+ third-party integrations",
   "main": "dist/index.js",
@@ -11,8 +11,9 @@
     ]
   },
   "scripts": {
-    "build": "tsc",
+    "build": "rm -rf dist && tsc",
     "test": "vitest run",
+    "test:live": "vitest run src/live.integration.test.ts",
     "prepublishOnly": "npm run build"
   },
   "files": [

package/dist/client.test.d.ts

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