@cometchat/skills 4.0.0 → 4.2.0

package/skills/cometchat-native-calls/references/server-push-payloads.md

@@ -0,0 +1,193 @@
+# Server-side push payloads for RN calls
+
+The RN client only handles received pushes. The server side — building and sending the payloads — is yours to implement. This reference is a copy-paste-ready Node.js example the skill points users at.
+
+---
+
+## What the server has to do
+
+1. Subscribe to CometChat's `call.received` webhook (Dashboard → Webhooks)
+2. When fired, look up the receiver UID's stored push tokens (PushKit + FCM)
+3. Send a VoIP-shaped payload to each platform with the right priority + cert
+
+Two endpoints, two payload shapes, one webhook. Simple but easy to get wrong.
+
+---
+
+## Express skeleton
+
+```ts
+// server/push-handler.ts
+import express from "express";
+import apn from "node-apn";                                  // npm i node-apn
+import admin from "firebase-admin";                          // npm i firebase-admin
+
+const app = express();
+app.use(express.json());
+
+// Initialize APNs (PushKit) provider with your VoIP cert
+const voipCert = apn.Provider({
+  token: undefined,
+  cert: process.env.APNS_VOIP_CERT_PATH,                    // path to your VoIP .p12 / .pem
+  key: process.env.APNS_VOIP_KEY_PATH,
+  passphrase: process.env.APNS_VOIP_PASSPHRASE,
+  production: process.env.NODE_ENV === "production",
+});
+
+// Initialize Firebase Admin
+admin.initializeApp({
+  credential: admin.credential.cert({
+    projectId: process.env.FIREBASE_PROJECT_ID!,
+    clientEmail: process.env.FIREBASE_CLIENT_EMAIL!,
+    privateKey: process.env.FIREBASE_PRIVATE_KEY!.replace(/\\n/g, "\n"),
+  }),
+});
+
+// CometChat webhook — fired when a call is initiated
+app.post("/webhook/cometchat/call-received", async (req, res) => {
+  const { receiver, sender, sessionId, type } = req.body.data;
+  const subs = await getPushSubscriptionsForUid(receiver);  // your DB
+
+  await Promise.allSettled([
+    ...subs.ios.map((token) => sendIOSVoip(token, { sessionId, callerName: sender.name, callerUid: sender.uid, callType: type })),
+    ...subs.android.map((token) => sendAndroidVoip(token, { sessionId, callerName: sender.name, callerUid: sender.uid, callType: type })),
+  ]);
+
+  res.status(200).send({ ok: true });
+});
+
+async function sendIOSVoip(token: string, payload: { sessionId: string; callerName: string; callerUid: string; callType: string }) {
+  const note = new apn.Notification();
+  note.topic = `${process.env.IOS_BUNDLE_ID}.voip`;          // CRITICAL: voip topic, not the bundle id
+  note.pushType = "voip";                                     // CRITICAL
+  note.priority = 10;
+  note.expiry = Math.floor(Date.now() / 1000) + 30;          // expire in 30s — call rings or doesn't
+  note.payload = {
+    "content-available": 1,
+    data: payload,
+  };
+
+  const result = await voipCert.send(note, token);
+  if (result.failed.length > 0) {
+    console.error("PushKit send failed:", result.failed);
+  }
+}
+
+async function sendAndroidVoip(token: string, payload: { sessionId: string; callerName: string; callerUid: string; callType: string }) {
+  await admin.messaging().send({
+    token,
+    android: {
+      priority: "high",                                       // CRITICAL — without this, FCM may delay
+      ttl: 30 * 1000,                                         // 30s TTL
+    },
+    data: {                                                   // CRITICAL — `data`, not `notification`
+      type: "incoming_call",
+      sessionId: payload.sessionId,
+      callerName: payload.callerName,
+      callerUid: payload.callerUid,
+      callType: payload.callType,
+    },
+  });
+}
+
+app.listen(3000);
+```
+
+The skill writes this file as `server/push.example.ts` next to a README pointing at the env vars + cert paths.
+
+---
+
+## Token registration endpoint
+
+The client sends its tokens to your server when the user logs in:
+
+```ts
+// Client side
+import VoipPushNotification from "react-native-voip-push-notification";
+import messaging from "@react-native-firebase/messaging";
+
+async function registerPushTokens(cometchatUid: string) {
+  if (Platform.OS === "ios") {
+    VoipPushNotification.addEventListener("register", async (token) => {
+      await fetch("/api/push/register", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ uid: cometchatUid, platform: "ios", token }),
+      });
+    });
+    VoipPushNotification.registerVoipToken();
+  } else {
+    const token = await messaging().getToken();
+    await fetch("/api/push/register", {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ uid: cometchatUid, platform: "android", token }),
+    });
+  }
+}
+```
+
+Server stores tokens keyed by `(cometchatUid, platform)`. On logout, call `/api/push/unregister` to clean up.
+
+---
+
+## Token rotation
+
+Both PushKit and FCM tokens can rotate without warning (OS upgrades, app reinstalls, expirations).
+
+- iOS PushKit: handle `didInvalidatePushToken` and re-register
+- FCM: handle `messaging().onTokenRefresh` and re-register
+
+```ts
+// iOS
+VoipPushNotification.addEventListener("didInvalidatePushToken", async () => {
+  // wait for next register event, will fire automatically
+});
+
+// Android
+messaging().onTokenRefresh(async (newToken) => {
+  await fetch("/api/push/register", {
+    method: "POST",
+    body: JSON.stringify({ uid: getCurrentUid(), platform: "android", token: newToken }),
+  });
+});
+```
+
+---
+
+## Webhook verification
+
+CometChat signs webhooks. Verify the signature before trusting payloads:
+
+```ts
+import crypto from "crypto";
+
+app.post("/webhook/cometchat/call-received", (req, res, next) => {
+  const signature = req.header("x-cometchat-signature");
+  const expected = crypto
+    .createHmac("sha256", process.env.COMETCHAT_WEBHOOK_SECRET!)
+    .update(JSON.stringify(req.body))
+    .digest("hex");
+  if (signature !== expected) return res.status(401).send({ error: "invalid signature" });
+  next();
+});
+```
+
+Without this, anyone with your endpoint URL can ring your users.
+
+---
+
+## Rate limits
+
+- **APNs:** 4000 notifications/sec per cert. Far above what an app needs for VoIP.
+- **FCM:** 1000 tokens per `send()` call (use `sendMulticast` for batches). Per-token rate limits not enforced strictly.
+
+For one-call-at-a-time semantics, you won't hit either. For broadcast scenarios (multi-party "ring everyone"), batch sends instead of looping `send()`.
+
+---
+
+## Testing the server locally
+
+ngrok the webhook endpoint to a public URL, register it in CometChat dashboard. Two real devices (one iOS, one Android) on real networks. Trigger a call from device A to device B; watch the server logs for the webhook fire and the push send.
+
+For unit tests, mock the apn + firebase-admin modules. Don't try to test real APNs/FCM in CI — certs and rate limits make it hostile.

package/skills/cometchat-native-calls/references/share-invite.md

@@ -0,0 +1,144 @@
+# Share invite on React Native
+
+Same SDK API as web. RN-specific: use the platform's native share sheet via `Share.share()` (built into RN) or `react-native-share` for richer options.
+
+**Canonical docs:** https://www.cometchat.com/docs/calls/react-native/share-invite
+**Read first:** `cometchat-react-calls/references/share-invite.md` — deep-link routing rule + dialog UX.
+
+---
+
+## Hard rule: deep-link routing
+
+Same rule as web. Configure your app's URL scheme + universal/app links so `https://yourapp.com/call/:sessionId` opens the app:
+
+```tsx
+// App.tsx — react-navigation linking config
+const linking = {
+  prefixes: ["https://yourapp.com", "yourapp://"],
+  config: {
+    screens: {
+      Call: "call/:sessionId",
+    },
+  },
+};
+
+<NavigationContainer linking={linking}>
+  {/* ... */}
+</NavigationContainer>
+```
+
+iOS: configure Associated Domains entitlement.
+Android: add `<intent-filter>` with `android:autoVerify="true"` to `AndroidManifest.xml`.
+
+Without these, share-invite URLs land in browser, not the app.
+
+---
+
+## SDK API
+
+```ts
+import { CometChatCalls } from "@cometchat/calls-sdk-react-native";
+
+const callSettings = new CallSettingsBuilder()
+  .setHideShareInviteButton(false)
+  .build();
+
+useEffect(() => {
+  const handler = () => shareCallInvite(sessionId);
+  CometChatCalls.addEventListener("onShareInviteButtonClicked", handler);
+  return () => CometChatCalls.removeEventListener("onShareInviteButtonClicked", handler);
+}, [sessionId]);
+```
+
+---
+
+## Native share sheet
+
+RN ships `Share` from `react-native`:
+
+```tsx
+import { Share, Platform } from "react-native";
+
+async function shareCallInvite(sessionId: string) {
+  const url = `https://yourapp.com/call/${sessionId}`;
+  const message = "I'm on a call — tap to join.";
+
+  try {
+    const result = await Share.share({
+      url: Platform.OS === "ios" ? url : undefined,  // iOS prefers `url`
+      message: Platform.OS === "android" ? `${message}\n${url}` : message,
+      title: "Join my call",  // Android only
+    });
+
+    if (result.action === Share.dismissedAction) {
+      // User cancelled — silent
+    }
+  } catch (err) {
+    console.warn("Share failed", err);
+  }
+}
+```
+
+`Share.share` opens iOS UIActivityViewController and Android's chooser intent. For both: pass `url` on iOS (separate field), append URL to `message` on Android (the `url` field is iOS-only).
+
+---
+
+## Clipboard fallback
+
+```tsx
+import Clipboard from "@react-native-clipboard/clipboard";
+import { Alert } from "react-native";
+
+async function copyLink(url: string) {
+  Clipboard.setString(url);
+  Alert.alert("Copied", "Call link copied to clipboard");
+}
+```
+
+Most apps don't need this — `Share.share` always succeeds, even if no targets are available it shows the system "no apps installed" toast. Clipboard is a nice-to-have alongside the share sheet, not a fallback.
+
+---
+
+## react-native-share for richer UX
+
+For per-channel buttons (just WhatsApp, just SMS, etc.):
+
+```tsx
+import Share from "react-native-share";
+
+await Share.shareSingle({
+  social: Share.Social.WHATSAPP,
+  message: "Join my call",
+  url: callLink,
+});
+```
+
+Use only if your UX requires it. Native share sheet is usually enough.
+
+---
+
+## Anti-patterns
+
+Web sister rules apply, plus RN-specific:
+
+1. **Setting `url` on Android Share.share.** Android ignores it; URL doesn't appear in shared content. Concat to `message` instead.
+2. **No deep-link config.** URL opens in browser → web fallback or 404.
+3. **Sharing without `await`.** Caller doesn't know if the user cancelled, success messaging fires for cancelled shares.
+
+---
+
+## Verification checklist
+
+- [ ] `react-navigation` `linking` config maps `/call/:sessionId`
+- [ ] Universal links (iOS) + auto-verified app links (Android) configured
+- [ ] `Share.share` URL field passed on iOS, concat'd to message on Android
+- [ ] Listener cleaned up on unmount
+- [ ] Real-device smoke: share via WhatsApp/Messages → tap → opens your app at the call
+
+---
+
+## Pointers
+
+- `cometchat-react-calls/references/share-invite.md` — sister
+- `cometchat-native-calls` SKILL.md
+- Canonical docs: https://www.cometchat.com/docs/calls/react-native/share-invite

package/skills/cometchat-native-calls/references/voip-push-end-to-end.md

@@ -0,0 +1,317 @@
+# VoIP push end-to-end on React Native
+
+The hardest piece of RN calls. This reference is the canonical implementation — the SKILL.md sketches it; here is the code.
+
+Stack:
+
+- **`react-native-callkeep`** — bridges CallKit (iOS) + ConnectionService (Android). One Dart-side API: "ring this device with this caller name."
+- **`react-native-voip-push-notification`** — iOS PushKit token registration and payload delivery
+- **`@react-native-firebase/messaging`** — Android FCM data messages
+- **Server-side** — your push server splits sends: PushKit (VoIP cert) for iOS, FCM with `priority: "high"` and `data` payload for Android
+
+---
+
+## iOS — PushKit + CallKit
+
+### Install + native config
+
+```bash
+npm install react-native-callkeep react-native-voip-push-notification
+cd ios && pod install && cd ..
+```
+
+In Xcode (manual steps the skill documents but cannot automate):
+
+1. Capabilities → Background Modes → enable: **Audio, AirPlay, and Picture in Picture** + **Voice over IP** + **Remote notifications**
+2. Capabilities → Push Notifications → ensure enabled
+3. Apple Developer portal → Certificates → create a **VoIP Services** certificate for your bundle ID (separate from the standard APNs cert)
+4. Upload the `.p12` to your push server
+
+### Info.plist
+
+```xml
+<key>UIBackgroundModes</key>
+<array>
+  <string>audio</string>
+  <string>voip</string>
+  <string>remote-notification</string>
+</array>
+<key>NSMicrophoneUsageDescription</key>
+<string>So you can talk during voice and video calls.</string>
+<key>NSCameraUsageDescription</key>
+<string>So you can be seen during video calls.</string>
+```
+
+### Register PushKit + CallKit at app launch
+
+```tsx
+// App.tsx
+import { useEffect } from "react";
+import VoipPushNotification from "react-native-voip-push-notification";
+import RNCallKeep from "react-native-callkeep";
+import { Platform } from "react-native";
+
+const callKeepOptions = {
+  ios: {
+    appName: "YourApp",
+    supportsVideo: true,
+    maximumCallGroups: 1,
+    maximumCallsPerCallGroup: 1,
+  },
+  android: {
+    alertTitle: "Permissions required",
+    alertDescription: "This app needs to access your phone calling system to ring you on incoming calls",
+    cancelButton: "Cancel",
+    okButton: "OK",
+    foregroundService: {
+      channelId: "com.yourapp.calls",
+      channelName: "Calls",
+      notificationTitle: "Call in progress",
+      notificationIcon: "ic_launcher",
+    },
+  },
+};
+
+export function App() {
+  useEffect(() => {
+    RNCallKeep.setup(callKeepOptions).then(() => {
+      RNCallKeep.setAvailable(true);
+    });
+
+    if (Platform.OS === "ios") {
+      // Register PushKit listener — iOS will call onRegister with the VoIP token
+      VoipPushNotification.addEventListener("register", (token) => {
+        // Send this token to your server, keyed by the logged-in CometChat UID
+        sendVoipTokenToServer(token);
+      });
+
+      // Incoming VoIP push payload arrives — IMMEDIATELY report to CallKit
+      VoipPushNotification.addEventListener("notification", (notification) => {
+        const { sessionId, callerName, callerUid } = notification.data;
+        // CRITICAL: this MUST happen within ~5s of payload delivery or iOS terminates the app
+        RNCallKeep.displayIncomingCall(
+          sessionId,                  // unique call UUID
+          callerUid,                  // handle
+          callerName,                 // localized caller name
+          "generic",                  // handle type
+          true,                       // hasVideo
+        );
+      });
+
+      VoipPushNotification.registerVoipToken();
+    }
+
+    if (Platform.OS === "android") {
+      setupAndroidVoipPush();
+    }
+
+    return () => {
+      VoipPushNotification.removeEventListener("register");
+      VoipPushNotification.removeEventListener("notification");
+    };
+  }, []);
+
+  // CallKit answer/end events — wire them to CometChat Calls SDK
+  useEffect(() => {
+    RNCallKeep.addEventListener("answerCall", async ({ callUUID }) => {
+      // sessionId === callUUID we passed to displayIncomingCall
+      await CometChatCalls.acceptCall(callUUID);
+      navigate("OngoingCall", { sessionId: callUUID });
+    });
+
+    RNCallKeep.addEventListener("endCall", async ({ callUUID }) => {
+      await CometChatCalls.leaveSession();
+    });
+
+    return () => {
+      RNCallKeep.removeEventListener("answerCall");
+      RNCallKeep.removeEventListener("endCall");
+    };
+  }, []);
+
+  return /* ...your nav... */;
+}
+```
+
+**5-second rule:** Apple terminates apps that delay `RNCallKeep.displayIncomingCall` more than ~5 seconds after PushKit delivery. Do not `await` async work before the call — display first, then do the rest from inside the answer handler.
+
+---
+
+## Android — FCM data messages + ConnectionService
+
+### Install + native config
+
+```bash
+npm install @react-native-firebase/app @react-native-firebase/messaging
+cd ios && pod install && cd ..    # iOS link for firebase even if you don't use iOS messaging
+```
+
+Place `google-services.json` (downloaded from Firebase console) at `android/app/google-services.json`.
+
+In `android/build.gradle`:
+
+```gradle
+buildscript {
+  dependencies {
+    classpath 'com.google.gms:google-services:4.4.0'
+  }
+}
+```
+
+In `android/app/build.gradle`:
+
+```gradle
+apply plugin: 'com.google.gms.google-services'
+```
+
+### AndroidManifest.xml
+
+```xml
+<uses-permission android:name="android.permission.INTERNET" />
+<uses-permission android:name="android.permission.RECORD_AUDIO" />
+<uses-permission android:name="android.permission.CAMERA" />
+<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+<uses-permission android:name="android.permission.WAKE_LOCK" />
+<uses-permission android:name="android.permission.POST_NOTIFICATIONS" />
+<uses-permission android:name="android.permission.MANAGE_OWN_CALLS" />
+<uses-permission android:name="android.permission.BIND_TELECOM_CONNECTION_SERVICE" tools:ignore="ProtectedPermissions" />
+
+<!-- Android 14+ -->
+<uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
+<uses-permission android:name="android.permission.FOREGROUND_SERVICE_PHONE_CALL" />
+<uses-permission android:name="android.permission.FOREGROUND_SERVICE_MICROPHONE" />
+<uses-permission android:name="android.permission.FOREGROUND_SERVICE_CAMERA" />
+
+<application>
+  <service
+    android:name="io.wazo.callkeep.RNCallKeepBackgroundMessagingService"
+    android:foregroundServiceType="phoneCall|microphone|camera"
+    android:exported="false" />
+</application>
+```
+
+The `tools` namespace must be declared on `<manifest>`: `xmlns:tools="http://schemas.android.com/tools"`.
+
+### Register FCM + handle data messages
+
+```ts
+import messaging from "@react-native-firebase/messaging";
+import RNCallKeep from "react-native-callkeep";
+
+async function setupAndroidVoipPush() {
+  await messaging().requestPermission();
+  const token = await messaging().getToken();
+  await sendFcmTokenToServer(token);
+
+  // Foreground messages — when app is open
+  messaging().onMessage(async (remoteMessage) => {
+    if (remoteMessage.data?.type === "incoming_call") {
+      handleIncomingCallPayload(remoteMessage.data);
+    }
+  });
+
+  // Background / killed app — registered in index.js (see below)
+}
+
+function handleIncomingCallPayload(data: Record<string, string>) {
+  RNCallKeep.displayIncomingCall(
+    data.sessionId,
+    data.callerUid,
+    data.callerName,
+    "generic",
+    true,
+  );
+}
+```
+
+### Background handler — must be in index.js, NOT a component
+
+```ts
+// index.js (top of file, before AppRegistry.registerComponent)
+import messaging from "@react-native-firebase/messaging";
+import RNCallKeep from "react-native-callkeep";
+
+messaging().setBackgroundMessageHandler(async (remoteMessage) => {
+  if (remoteMessage.data?.type === "incoming_call") {
+    RNCallKeep.displayIncomingCall(
+      remoteMessage.data.sessionId,
+      remoteMessage.data.callerUid,
+      remoteMessage.data.callerName,
+      "generic",
+      true,
+    );
+  }
+});
+```
+
+Background handler must register in `index.js` so it's invoked when the JS engine boots in background-headless mode.
+
+---
+
+## Server-side push payload shape
+
+Your push server gets the call event from CometChat (via webhook) and dispatches:
+
+### iOS payload (PushKit — sent via APNs with `apns-push-type: voip`)
+
+```json
+{
+  "aps": {
+    "content-available": 1
+  },
+  "data": {
+    "sessionId": "session-abc-123",
+    "callerName": "Alice",
+    "callerUid": "cometchat-uid-1",
+    "callType": "video"
+  }
+}
+```
+
+Send to the **VoIP-specific** APNs endpoint with the VoIP cert. Standard APNs cert won't work.
+
+### Android payload (FCM data message)
+
+```json
+{
+  "to": "<receiver-fcm-token>",
+  "priority": "high",
+  "data": {
+    "type": "incoming_call",
+    "sessionId": "session-abc-123",
+    "callerName": "Alice",
+    "callerUid": "cometchat-uid-1",
+    "callType": "video"
+  }
+}
+```
+
+**`data` not `notification`.** ConnectionService cannot intercept `notification` payloads — they go to the system tray. Only `data` payloads invoke the background handler.
+
+`priority: "high"` is required. Without it, FCM may delay delivery by minutes — too slow to ring.
+
+---
+
+## Common failure modes
+
+| Symptom | Cause | Fix |
+|---|---|---|
+| iOS: incoming call doesn't ring on lock screen | VoIP cert not uploaded to push server, or not matched to bundle ID | Verify cert in Apple Dev portal; rotate if expired |
+| iOS: app crashes ~5s after PushKit delivery | Async work before `displayIncomingCall` | Display first, then do the rest in the answer handler |
+| iOS: PushKit token never registers | Background Modes capability missing | Re-check Xcode capabilities; uninstall + reinstall app to retrigger registration |
+| Android: incoming call shows as a regular notification (not heads-up) | Sent as `notification` instead of `data` | Server must use FCM `data` payload exclusively |
+| Android: incoming call delayed by minutes | `priority` missing or `"normal"` | Server must set `priority: "high"` |
+| Android 14+: app crashes on call start | Wrong `foregroundServiceType` | Must include `phoneCall` (silent crash with `microphone\|camera` only) |
+| Android: ConnectionService not invoked | `MANAGE_OWN_CALLS` permission denied at runtime | Show rationale dialog and re-request |
+| Both: lock-screen UI stuck after call ends | Missing `RNCallKeep.endCall` in hangup path | Add `RNCallKeep.endCall(callUUID)` to the cleanup |
+
+---
+
+## Testing VoIP push (without a server)
+
+The hardest part of dev is iterating without a real push server. Two workarounds:
+
+1. **Trigger CallKit directly without push** — call `RNCallKeep.displayIncomingCall(...)` from a debug button in your app. Bypasses the server entirely. Useful for testing the in-app flow.
+2. **Use Firebase Console "Send test message"** — send a one-off FCM `data` payload to a specific token. Does NOT support PushKit — iOS still needs a real VoIP push server.
+
+For real end-to-end tests, you need a push server. The skill scaffolds a tiny Express example (`server/push.example.ts`) that the user runs locally; it's documented but not tested in CI because real APNs/FCM requires real certs.

package/skills/cometchat-native-components/SKILL.md

@@ -3,7 +3,7 @@ name: cometchat-native-components
 description: "Component catalog for the CometChat React Native UI Kit v5 — names, props, slot views, request builders, hide flags, style shape. Always loaded before writing CometChat* JSX."
 license: "MIT"
 compatibility: "Node.js >=18; React Native >=0.70; @cometchat/chat-uikit-react-native ^5"
-allowed-tools: "executeBash, readFile, fileSearch, listDirectory, AskUserQuestion"
+allowed-tools: "shell, file-read, file-search, file-list, ask-user"
 metadata:
   author: "CometChat"
   version: "3.0.0"

package/skills/cometchat-native-core/SKILL.md

@@ -3,7 +3,7 @@ name: cometchat-native-core
 description: "Shared rules for CometChat React Native UI Kit v5. Always loaded alongside framework (expo/bare) and placement skills. Read this first."
 license: "MIT"
 compatibility: "Node.js >=18; React Native >=0.70; @cometchat/chat-uikit-react-native ^5; @cometchat/chat-sdk-react-native ^4"
-allowed-tools: "executeBash, readFile, fileSearch, listDirectory"
+allowed-tools: "shell, file-read, file-search, file-list"
 metadata:
   author: "CometChat"
   version: "3.0.0"

package/skills/cometchat-native-customization/SKILL.md

@@ -3,7 +3,7 @@ name: cometchat-native-customization
 description: "Customize the CometChat React Native UI Kit without forking — four-tier model: props → request builders → text formatters + message templates → DataSource decorators + event bus."
 license: "MIT"
 compatibility: "Node.js >=18; React Native >=0.70; @cometchat/chat-uikit-react-native ^5"
-allowed-tools: "executeBash, readFile, fileSearch, listDirectory, AskUserQuestion"
+allowed-tools: "shell, file-read, file-search, file-list, ask-user"
 metadata:
   author: "CometChat"
   version: "3.0.0"