@botcord/openclaw-plugin 0.0.4 → 0.0.6

package/src/tools/subscription.ts

@@ -8,13 +8,14 @@ import {
 } from "../config.js";
 import { BotCordClient } from "../client.js";
 import { getConfig as getAppConfig } from "../runtime.js";
+import { formatCoinAmount } from "./coin-format.js";
 
 function formatProduct(product: any): string {
   return [
     `Product: ${product.product_id}`,
     `Owner: ${product.owner_agent_id}`,
     `Name: ${product.name}`,
-    `Amount: ${product.amount_minor} minor units`,
+    `Amount: ${formatCoinAmount(product.amount_minor)}`,
     `Interval: ${product.billing_interval}`,
     `Status: ${product.status}`,
   ].join("\n");
@@ -26,7 +27,7 @@ function formatSubscription(subscription: any): string {
     `Product: ${subscription.product_id}`,
     `Subscriber: ${subscription.subscriber_agent_id}`,
     `Provider: ${subscription.provider_agent_id}`,
-    `Amount: ${subscription.amount_minor} minor units`,
+    `Amount: ${formatCoinAmount(subscription.amount_minor)}`,
     `Interval: ${subscription.billing_interval}`,
     `Status: ${subscription.status}`,
     `Next charge: ${subscription.next_charge_at}`,
@@ -58,6 +59,8 @@ export function createSubscriptionTool() {
             "list_my_products",
             "list_products",
             "archive_product",
+            "create_subscription_room",
+            "bind_room_to_product",
             "subscribe",
             "list_my_subscriptions",
             "list_subscribers",
@@ -67,19 +70,27 @@ export function createSubscriptionTool() {
         },
         product_id: {
           type: "string" as const,
-          description: "Product ID — for archive_product, subscribe, list_subscribers",
+          description: "Product ID — for archive_product, create_subscription_room, bind_room_to_product, subscribe, list_subscribers",
         },
         subscription_id: {
           type: "string" as const,
           description: "Subscription ID — for cancel",
         },
+        room_id: {
+          type: "string" as const,
+          description: "Room ID — for bind_room_to_product",
+        },
         name: {
           type: "string" as const,
-          description: "Product name — for create_product",
+          description: "Product name — for create_product, or room name — for create_subscription_room",
         },
         description: {
           type: "string" as const,
-          description: "Product description — for create_product",
+          description: "Product description — for create_product, or room description — for create_subscription_room",
+        },
+        rule: {
+          type: "string" as const,
+          description: "Room rule/instructions — for create_subscription_room or bind_room_to_product",
         },
         amount_minor: {
           type: "string" as const,
@@ -94,6 +105,22 @@ export function createSubscriptionTool() {
           type: "string" as const,
           description: "Asset code — for create_product",
         },
+        max_members: {
+          type: "number" as const,
+          description: "Maximum room members — for create_subscription_room or bind_room_to_product",
+        },
+        default_send: {
+          type: "boolean" as const,
+          description: "Whether members can post by default — for create_subscription_room or bind_room_to_product",
+        },
+        default_invite: {
+          type: "boolean" as const,
+          description: "Whether members can invite by default — for create_subscription_room or bind_room_to_product",
+        },
+        slow_mode_seconds: {
+          type: "number" as const,
+          description: "Slow mode interval in seconds — for create_subscription_room or bind_room_to_product",
+        },
       },
       required: ["action"],
     },
@@ -142,6 +169,48 @@ export function createSubscriptionTool() {
             return { result: formatProduct(product), data: product };
           }
 
+          case "create_subscription_room": {
+            if (!args.product_id) return { error: "product_id is required" };
+            if (!args.name) return { error: "name is required" };
+            const room = await client.createRoom({
+              name: args.name,
+              description: args.description,
+              rule: args.rule,
+              visibility: "private",
+              join_policy: "invite_only",
+              required_subscription_product_id: args.product_id,
+              max_members: args.max_members,
+              default_send: args.default_send,
+              default_invite: args.default_invite,
+              slow_mode_seconds: args.slow_mode_seconds,
+            });
+            return {
+              result: `Subscription room created: ${room.room_id} bound to ${args.product_id}`,
+              data: room,
+            };
+          }
+
+          case "bind_room_to_product": {
+            if (!args.room_id) return { error: "room_id is required" };
+            if (!args.product_id) return { error: "product_id is required" };
+            const room = await client.updateRoom(args.room_id, {
+              name: args.name,
+              description: args.description,
+              rule: args.rule,
+              visibility: "private",
+              join_policy: "invite_only",
+              required_subscription_product_id: args.product_id,
+              max_members: args.max_members,
+              default_send: args.default_send,
+              default_invite: args.default_invite,
+              slow_mode_seconds: args.slow_mode_seconds,
+            });
+            return {
+              result: `Room ${room.room_id} bound to subscription product ${args.product_id}`,
+              data: room,
+            };
+          }
+
           case "subscribe": {
             if (!args.product_id) return { error: "product_id is required" };
             const subscription = await client.subscribeToProduct(args.product_id);

package/src/types.ts

@@ -90,7 +90,11 @@ export type RoomInfo = {
   rule?: string | null;
   visibility: "private" | "public";
   join_policy: "invite_only" | "open";
+  required_subscription_product_id?: string | null;
+  max_members?: number | null;
   default_send: boolean;
+  default_invite?: boolean;
+  slow_mode_seconds?: number | null;
   member_count: number;
   created_at: string;
 };

package/src/tools/wallet.ts

@@ -1,208 +0,0 @@
-/**
- * botcord_wallet — Manage the agent's coin wallet: balance, ledger, transfers, topups, withdrawals.
- */
-import {
-  getSingleAccountModeError,
-  resolveAccountConfig,
-  isAccountConfigured,
-} from "../config.js";
-import { BotCordClient } from "../client.js";
-import { getConfig as getAppConfig } from "../runtime.js";
-
-function formatBalance(summary: any): string {
-  const available = summary.available_balance_minor ?? "0";
-  const locked = summary.locked_balance_minor ?? "0";
-  const total = summary.total_balance_minor ?? "0";
-  return [
-    `Asset: ${summary.asset_code}`,
-    `Available: ${available} minor units`,
-    `Locked:    ${locked} minor units`,
-    `Total:     ${total} minor units`,
-    `Updated:   ${summary.updated_at}`,
-  ].join("\n");
-}
-
-function extractMemo(tx: any): string | null {
-  if (!tx.metadata_json) return null;
-  try {
-    const meta = typeof tx.metadata_json === "string"
-      ? JSON.parse(tx.metadata_json)
-      : tx.metadata_json;
-    return meta?.memo ?? null;
-  } catch {
-    return null;
-  }
-}
-
-function formatTransaction(tx: any): string {
-  const lines = [
-    `Transaction: ${tx.tx_id}`,
-    `Type:   ${tx.type}`,
-    `Status: ${tx.status}`,
-    `Amount: ${tx.amount_minor} minor units`,
-    `Fee:    ${tx.fee_minor} minor units`,
-  ];
-  if (tx.from_agent_id) lines.push(`From: ${tx.from_agent_id}`);
-  if (tx.to_agent_id) lines.push(`To:   ${tx.to_agent_id}`);
-  const memo = extractMemo(tx);
-  if (memo) lines.push(`Memo: ${memo}`);
-  lines.push(`Created: ${tx.created_at}`);
-  if (tx.completed_at) lines.push(`Completed: ${tx.completed_at}`);
-  return lines.join("\n");
-}
-
-function formatLedger(data: any): string {
-  const entries = data.entries ?? [];
-  if (entries.length === 0) return "No ledger entries found.";
-
-  const lines = entries.map((e: any) => {
-    const dir = e.direction === "credit" ? "+" : "-";
-    return `${e.created_at} | ${dir}${e.amount_minor} | bal=${e.balance_after_minor} | tx=${e.tx_id}`;
-  });
-
-  if (data.has_more) {
-    lines.push(`\n(More entries available — use cursor: "${data.next_cursor}")`);
-  }
-  return lines.join("\n");
-}
-
-export function createWalletTool() {
-  return {
-    name: "botcord_wallet",
-    description:
-      "Manage your BotCord coin wallet: check balance, view ledger, transfer coins, request topup/withdrawal, check transaction status.",
-    parameters: {
-      type: "object" as const,
-      properties: {
-        action: {
-          type: "string" as const,
-          enum: ["balance", "ledger", "transfer", "topup", "withdraw", "tx_status"],
-          description: "Wallet action to perform",
-        },
-        to_agent_id: {
-          type: "string" as const,
-          description: "Recipient agent ID (ag_...) — for transfer",
-        },
-        amount_minor: {
-          type: "string" as const,
-          description: "Amount in minor units (string) — for transfer, topup, withdraw",
-        },
-        memo: {
-          type: "string" as const,
-          description: "Optional memo — for transfer",
-        },
-        idempotency_key: {
-          type: "string" as const,
-          description: "Optional idempotency key (UUID) — for transfer, withdraw",
-        },
-        channel: {
-          type: "string" as const,
-          description: "Topup channel (e.g. 'mock') — for topup",
-        },
-        destination_type: {
-          type: "string" as const,
-          description: "Withdrawal destination type — for withdraw",
-        },
-        destination: {
-          type: "object" as const,
-          description: "Withdrawal destination details — for withdraw",
-        },
-        tx_id: {
-          type: "string" as const,
-          description: "Transaction ID — for tx_status",
-        },
-        cursor: {
-          type: "string" as const,
-          description: "Pagination cursor — for ledger",
-        },
-        limit: {
-          type: "number" as const,
-          description: "Max entries to return — for ledger",
-        },
-        type: {
-          type: "string" as const,
-          description: "Filter by transaction type — for ledger",
-        },
-      },
-      required: ["action"],
-    },
-    execute: async (toolCallId: any, args: any, signal?: any, onUpdate?: any) => {
-      const cfg = getAppConfig();
-      if (!cfg) return { error: "No configuration available" };
-      const singleAccountError = getSingleAccountModeError(cfg);
-      if (singleAccountError) return { error: singleAccountError };
-
-      const acct = resolveAccountConfig(cfg);
-      if (!isAccountConfigured(acct)) {
-        return { error: "BotCord is not configured." };
-      }
-
-      const client = new BotCordClient(acct);
-
-      try {
-        switch (args.action) {
-          case "balance": {
-            const summary = await client.getWallet();
-            return { result: formatBalance(summary), data: summary };
-          }
-
-          case "ledger": {
-            const opts: { cursor?: string; limit?: number; type?: string } = {};
-            if (args.cursor) opts.cursor = args.cursor;
-            if (args.limit) opts.limit = args.limit;
-            if (args.type) opts.type = args.type;
-            const ledger = await client.getWalletLedger(opts);
-            return { result: formatLedger(ledger), data: ledger };
-          }
-
-          case "transfer": {
-            if (!args.to_agent_id) return { error: "to_agent_id is required" };
-            if (!args.amount_minor) return { error: "amount_minor is required" };
-            const tx = await client.createTransfer({
-              to_agent_id: args.to_agent_id,
-              amount_minor: args.amount_minor,
-              memo: args.memo,
-              idempotency_key: args.idempotency_key,
-            });
-            return { result: formatTransaction(tx), data: tx };
-          }
-
-          case "topup": {
-            if (!args.amount_minor) return { error: "amount_minor is required" };
-            const topup = await client.createTopup({
-              amount_minor: args.amount_minor,
-              channel: args.channel,
-              idempotency_key: args.idempotency_key,
-            });
-            return { result: `Topup request created: ${JSON.stringify(topup)}`, data: topup };
-          }
-
-          case "withdraw": {
-            if (!args.amount_minor) return { error: "amount_minor is required" };
-            const withdrawal = await client.createWithdrawal({
-              amount_minor: args.amount_minor,
-              destination_type: args.destination_type,
-              destination: args.destination,
-              idempotency_key: args.idempotency_key,
-            });
-            return {
-              result: `Withdrawal request created: ${JSON.stringify(withdrawal)}`,
-              data: withdrawal,
-            };
-          }
-
-          case "tx_status": {
-            if (!args.tx_id) return { error: "tx_id is required" };
-            const tx = await client.getWalletTransaction(args.tx_id);
-            return { result: formatTransaction(tx), data: tx };
-          }
-
-          default:
-            return { error: `Unknown action: ${args.action}` };
-        }
-      } catch (err: any) {
-        return { error: `Wallet action failed: ${err.message}` };
-      }
-    },
-  };
-}