@happycastle/openclaw-channel-talk 0.1.0 → 0.2.0

package/openclaw.plugin.json

@@ -6,6 +6,55 @@
   "configSchema": {
     "type": "object",
     "additionalProperties": false,
-    "properties": {}
+    "properties": {
+      "enabled": {
+        "type": "boolean",
+        "default": true,
+        "description": "Enable/disable the Channel Talk plugin"
+      },
+      "accessKey": {
+        "type": "string",
+        "description": "Channel Talk access key for API authentication"
+      },
+      "accessSecret": {
+        "type": "string",
+        "description": "Channel Talk access secret for API authentication"
+      },
+      "webhook": {
+        "type": "object",
+        "properties": {
+          "port": {
+            "type": "number",
+            "default": 3979,
+            "description": "Port for webhook server"
+          },
+          "path": {
+            "type": "string",
+            "default": "/api/channel-talk",
+            "description": "Path for webhook endpoint"
+          }
+        }
+      },
+      "botName": {
+        "type": "string",
+        "description": "Bot display name for sent messages"
+      },
+      "groupPolicy": {
+        "type": "string",
+        "enum": ["open", "closed"],
+        "default": "open",
+        "description": "Group chat policy"
+      },
+      "allowedGroups": {
+        "type": "array",
+        "items": { "type": "string" },
+        "description": "List of group chatIds to respond to"
+      },
+      "mentionOnly": {
+        "type": "boolean",
+        "default": false,
+        "description": "Only respond when the bot is mentioned"
+      }
+    }
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@happycastle/openclaw-channel-talk",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "OpenClaw Channel Talk (채널톡) Team Chat channel plugin",
   "type": "module",
   "license": "MIT",

package/src/channel.ts

@@ -1,5 +1,5 @@
 import type { ChannelPlugin, OpenClawConfig } from 'openclaw/plugin-sdk';
-import { buildChannelConfigSchema, DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk';
+import { DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk';
 import type { ChannelTalkCredentials } from './types.js';
 import { ChannelTalkConfigSchema } from './config-schema.js';
 import { channelTalkOutbound } from './send.js';
@@ -56,7 +56,7 @@ export const channelTalkPlugin: ChannelPlugin<ResolvedChannelTalkAccount> = {
 
   reload: { configPrefixes: ['channels.channel-talk'] },
 
-  configSchema: buildChannelConfigSchema(ChannelTalkConfigSchema as any),
+  configSchema: ChannelTalkConfigSchema,
 
   config: {
     listAccountIds: () => [DEFAULT_ACCOUNT_ID],

package/src/config-schema.ts

@@ -1,60 +1,90 @@
 /**
  * Channel Talk Plugin Configuration Schema
- * Defines the structure and validation for Channel Talk plugin configuration
+ * Plain JSON Schema — avoids TypeBox compatibility issues with OpenClaw's config validator.
  */
 
-import { Type } from '@sinclair/typebox';
-import type { Static } from '@sinclair/typebox';
-
-/**
- * Channel Talk configuration schema using TypeBox
- * Defines required and optional configuration fields for the plugin
- */
-export const ChannelTalkConfigSchema = Type.Object(
-  {
+export const ChannelTalkConfigSchema = {
+  type: 'object' as const,
+  additionalProperties: false,
+  properties: {
     /** Enable/disable the Channel Talk plugin */
-    enabled: Type.Optional(Type.Boolean({ default: true })),
-    
+    enabled: {
+      type: 'boolean' as const,
+      default: true,
+      description: 'Enable/disable the Channel Talk plugin',
+    },
+
     /** Channel Talk API access key (required when enabled) */
-    accessKey: Type.String({
+    accessKey: {
+      type: 'string' as const,
       description: 'Channel Talk access key for API authentication',
-    }),
-    
+    },
+
     /** Channel Talk API access secret (required when enabled) */
-    accessSecret: Type.String({
+    accessSecret: {
+      type: 'string' as const,
       description: 'Channel Talk access secret for API authentication',
-    }),
-    
+    },
+
     /** Webhook configuration */
-    webhook: Type.Optional(
-      Type.Object({
-        /** Port for webhook server (default: 3979) */
-        port: Type.Optional(Type.Number({ default: 3979 })),
-        
-        /** Path for webhook endpoint (default: /api/channel-talk) */
-        path: Type.Optional(Type.String({ default: '/api/channel-talk' })),
-      })
-    ),
-    
+    webhook: {
+      type: 'object' as const,
+      properties: {
+        port: {
+          type: 'number' as const,
+          default: 3979,
+          description: 'Port for webhook server (default: 3979)',
+        },
+        path: {
+          type: 'string' as const,
+          default: '/api/channel-talk',
+          description: 'Path for webhook endpoint (default: /api/channel-talk)',
+        },
+      },
+    },
+
     /** Bot display name for sent messages (optional) */
-    botName: Type.Optional(
-      Type.String({
-        description: 'Bot display name for sent messages',
-      })
-    ),
-    
-    /** Group chat policy: 'open' = all groups allowed, 'closed' = none allowed */
-    groupPolicy: Type.Optional(
-      Type.Enum(['open', 'closed'], { default: 'open' })
-    ),
+    botName: {
+      type: 'string' as const,
+      description: 'Bot display name for sent messages',
+    },
+
+    /** Group chat policy: "open" = all groups allowed, "closed" = none allowed */
+    groupPolicy: {
+      type: 'string' as const,
+      enum: ['open', 'closed'],
+      default: 'open',
+      description: 'Group chat policy: "open" = all groups allowed, "closed" = none',
+    },
+
+    /** Allowlist of group chatIds to respond to */
+    allowedGroups: {
+      type: 'array' as const,
+      items: { type: 'string' as const },
+      description:
+        'List of group chatIds to respond to. If empty or omitted, all groups are allowed (subject to groupPolicy).',
+    },
+
+    /** Only respond when the bot is mentioned */
+    mentionOnly: {
+      type: 'boolean' as const,
+      default: false,
+      description:
+        'Only respond when the bot is mentioned in the message. Similar to Discord mention-only mode.',
+    },
   },
-  {
-    additionalProperties: false,
-  }
-);
+};
 
 /**
- * TypeScript type derived from the schema
- * Use this for type-safe configuration handling
+ * TypeScript type for the config (manual, not derived from TypeBox)
  */
-export type ChannelTalkConfig = Static<typeof ChannelTalkConfigSchema>;
+export interface ChannelTalkConfig {
+  enabled?: boolean;
+  accessKey: string;
+  accessSecret: string;
+  webhook?: { port?: number; path?: string };
+  botName?: string;
+  groupPolicy?: 'open' | 'closed';
+  allowedGroups?: string[];
+  mentionOnly?: boolean;
+}

package/src/webhook.ts

@@ -8,6 +8,27 @@ const DEFAULT_ACCOUNT_ID = 'default';
 const DEDUP_TTL_MS = 60_000;
 const DEDUP_CLEANUP_INTERVAL_MS = 30_000;
 
+/**
+ * Check if a message mentions the bot.
+ * Matches @botName or common patterns like "봇이름아", "봇이름아,", etc.
+ * If no botName is configured, always returns false (falls through to respond to all).
+ */
+function checkMention(text: string, botName?: string): boolean {
+  if (!botName) return false;
+  const lower = text.toLowerCase();
+  const nameLower = botName.toLowerCase();
+  // Direct @mention
+  if (lower.includes(`@${nameLower}`)) return true;
+  // Name appears at start or as a word boundary
+  const namePattern = new RegExp(`(?:^|\\s)${escapeRegex(nameLower)}(?:[아야,!?\\s]|$)`, 'i');
+  if (namePattern.test(text)) return true;
+  return false;
+}
+
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
 export type StartChannelTalkWebhookContext = {
   cfg: OpenClawConfig;
   runtime: { log?: (...args: unknown[]) => void; error?: (...args: unknown[]) => void };
@@ -56,6 +77,8 @@ export async function startChannelTalkWebhook(
   const webhookPath = webhookCfg?.path ?? '/api/channel-talk';
   const botName = channelTalkCfg.botName as string | undefined;
   const accountId = ctx.accountId ?? DEFAULT_ACCOUNT_ID;
+  const allowedGroups = channelTalkCfg.allowedGroups as string[] | undefined;
+  const mentionOnly = channelTalkCfg.mentionOnly as boolean | undefined;
 
   const apiClient = createApiClient({ accessKey, accessSecret }, channelTalkCfg.baseUrl as string | undefined);
 
@@ -151,6 +174,24 @@ export async function startChannelTalkWebhook(
       return;
     }
 
+    // --- Group allowlist filtering ---
+    if (allowedGroups && allowedGroups.length > 0) {
+      if (!allowedGroups.includes(groupId)) {
+        log.debug?.('skipping message from non-allowed group', { groupId });
+        return;
+      }
+    }
+
+    // --- Mention-only filtering ---
+    const wasMentioned = mentionOnly
+      ? checkMention(plainText, botName)
+      : false;
+
+    if (mentionOnly && !wasMentioned) {
+      log.debug?.('skipping non-mentioned message (mentionOnly=true)', { groupId });
+      return;
+    }
+
     const managerId = refers?.manager?.id ?? entity.personId ?? 'unknown';
     const managerName = refers?.manager?.name ?? managerId;
     const timestamp = entity.createdAt ?? Date.now();
@@ -215,7 +256,7 @@ export async function startChannelTalkWebhook(
       Surface: 'channel-talk' as const,
       MessageSid: messageId,
       Timestamp: timestamp,
-      WasMentioned: false,
+      WasMentioned: wasMentioned || !mentionOnly,
       CommandAuthorized: false,
       OriginatingChannel: 'channel-talk' as const,
       OriginatingTo: `group:${groupId}`,