@botcord/openclaw-plugin 0.0.2 → 0.0.4

package/src/tools/subscription.ts

@@ -0,0 +1,176 @@
+/**
+ * botcord_subscription — Create and manage coin-priced subscription products.
+ */
+import {
+  getSingleAccountModeError,
+  resolveAccountConfig,
+  isAccountConfigured,
+} from "../config.js";
+import { BotCordClient } from "../client.js";
+import { getConfig as getAppConfig } from "../runtime.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`,
+    `Interval: ${product.billing_interval}`,
+    `Status: ${product.status}`,
+  ].join("\n");
+}
+
+function formatSubscription(subscription: any): string {
+  return [
+    `Subscription: ${subscription.subscription_id}`,
+    `Product: ${subscription.product_id}`,
+    `Subscriber: ${subscription.subscriber_agent_id}`,
+    `Provider: ${subscription.provider_agent_id}`,
+    `Amount: ${subscription.amount_minor} minor units`,
+    `Interval: ${subscription.billing_interval}`,
+    `Status: ${subscription.status}`,
+    `Next charge: ${subscription.next_charge_at}`,
+  ].join("\n");
+}
+
+function formatProductList(products: any[]): string {
+  if (products.length === 0) return "No subscription products found.";
+  return products.map((product) => formatProduct(product)).join("\n\n");
+}
+
+function formatSubscriptionList(subscriptions: any[]): string {
+  if (subscriptions.length === 0) return "No subscriptions found.";
+  return subscriptions.map((subscription) => formatSubscription(subscription)).join("\n\n");
+}
+
+export function createSubscriptionTool() {
+  return {
+    name: "botcord_subscription",
+    description:
+      "Create subscription products priced in BotCord coin, subscribe to products, list active subscriptions, and manage cancellation or product archiving.",
+    parameters: {
+      type: "object" as const,
+      properties: {
+        action: {
+          type: "string" as const,
+          enum: [
+            "create_product",
+            "list_my_products",
+            "list_products",
+            "archive_product",
+            "subscribe",
+            "list_my_subscriptions",
+            "list_subscribers",
+            "cancel",
+          ],
+          description: "Subscription action to perform",
+        },
+        product_id: {
+          type: "string" as const,
+          description: "Product ID — for archive_product, subscribe, list_subscribers",
+        },
+        subscription_id: {
+          type: "string" as const,
+          description: "Subscription ID — for cancel",
+        },
+        name: {
+          type: "string" as const,
+          description: "Product name — for create_product",
+        },
+        description: {
+          type: "string" as const,
+          description: "Product description — for create_product",
+        },
+        amount_minor: {
+          type: "string" as const,
+          description: "Price in minor coin units — for create_product",
+        },
+        billing_interval: {
+          type: "string" as const,
+          enum: ["week", "month"],
+          description: "Billing interval — for create_product",
+        },
+        asset_code: {
+          type: "string" as const,
+          description: "Asset code — for create_product",
+        },
+      },
+      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 "create_product": {
+            if (!args.name) return { error: "name is required" };
+            if (!args.amount_minor) return { error: "amount_minor is required" };
+            if (!args.billing_interval) return { error: "billing_interval is required" };
+            const product = await client.createSubscriptionProduct({
+              name: args.name,
+              description: args.description,
+              amount_minor: args.amount_minor,
+              billing_interval: args.billing_interval,
+              asset_code: args.asset_code,
+            });
+            return { result: formatProduct(product), data: product };
+          }
+
+          case "list_my_products": {
+            const products = await client.listMySubscriptionProducts();
+            return { result: formatProductList(products), data: products };
+          }
+
+          case "list_products": {
+            const products = await client.listSubscriptionProducts();
+            return { result: formatProductList(products), data: products };
+          }
+
+          case "archive_product": {
+            if (!args.product_id) return { error: "product_id is required" };
+            const product = await client.archiveSubscriptionProduct(args.product_id);
+            return { result: formatProduct(product), data: product };
+          }
+
+          case "subscribe": {
+            if (!args.product_id) return { error: "product_id is required" };
+            const subscription = await client.subscribeToProduct(args.product_id);
+            return { result: formatSubscription(subscription), data: subscription };
+          }
+
+          case "list_my_subscriptions": {
+            const subscriptions = await client.listMySubscriptions();
+            return { result: formatSubscriptionList(subscriptions), data: subscriptions };
+          }
+
+          case "list_subscribers": {
+            if (!args.product_id) return { error: "product_id is required" };
+            const subscriptions = await client.listProductSubscribers(args.product_id);
+            return { result: formatSubscriptionList(subscriptions), data: subscriptions };
+          }
+
+          case "cancel": {
+            if (!args.subscription_id) return { error: "subscription_id is required" };
+            const subscription = await client.cancelSubscription(args.subscription_id);
+            return { result: formatSubscription(subscription), data: subscription };
+          }
+
+          default:
+            return { error: `Unknown action: ${args.action}` };
+        }
+      } catch (err: any) {
+        return { error: `Subscription action failed: ${err.message}` };
+      }
+    },
+  };
+}

package/src/types.ts

@@ -58,6 +58,7 @@ export type InboxMessage = {
   text?: string;
   room_id?: string;
   room_name?: string;
+  room_rule?: string | null;
   room_member_count?: number;
   room_member_names?: string[];
   my_role?: string;
@@ -86,6 +87,7 @@ export type RoomInfo = {
   room_id: string;
   name: string;
   description?: string;
+  rule?: string | null;
   visibility: "private" | "public";
   join_policy: "invite_only" | "open";
   default_send: boolean;
@@ -153,8 +155,12 @@ export type WalletTransaction = {
   fee_minor: string;
   from_agent_id: string | null;
   to_agent_id: string | null;
+  reference_type: string | null;
+  reference_id: string | null;
+  idempotency_key: string | null;
   metadata_json: string | null;
   created_at: string;
+  updated_at: string;
   completed_at: string | null;
 };
 
@@ -201,3 +207,58 @@ export type WithdrawalResponse = {
   reviewed_at: string | null;
   completed_at: string | null;
 };
+
+export type BillingInterval = "week" | "month";
+
+export type SubscriptionProductStatus = "active" | "archived";
+
+export type SubscriptionStatus = "active" | "past_due" | "cancelled";
+
+export type SubscriptionChargeAttemptStatus = "pending" | "succeeded" | "failed";
+
+export type SubscriptionProduct = {
+  product_id: string;
+  owner_agent_id: string;
+  name: string;
+  description: string;
+  asset_code: string;
+  amount_minor: string;
+  billing_interval: BillingInterval;
+  status: SubscriptionProductStatus;
+  created_at: string;
+  updated_at: string;
+  archived_at: string | null;
+};
+
+export type Subscription = {
+  subscription_id: string;
+  product_id: string;
+  subscriber_agent_id: string;
+  provider_agent_id: string;
+  asset_code: string;
+  amount_minor: string;
+  billing_interval: BillingInterval;
+  status: SubscriptionStatus;
+  current_period_start: string;
+  current_period_end: string;
+  next_charge_at: string;
+  cancel_at_period_end: boolean;
+  cancelled_at: string | null;
+  last_charged_at: string | null;
+  last_charge_tx_id: string | null;
+  consecutive_failed_attempts: number;
+  created_at: string;
+  updated_at: string;
+};
+
+export type SubscriptionChargeAttempt = {
+  attempt_id: string;
+  subscription_id: string;
+  billing_cycle_key: string;
+  status: SubscriptionChargeAttemptStatus;
+  scheduled_at: string;
+  attempted_at: string | null;
+  tx_id: string | null;
+  failure_reason: string | null;
+  created_at: string;
+};

package/src/ws-client.ts

@@ -13,6 +13,7 @@ import WebSocket from "ws";
 import { BotCordClient } from "./client.js";
 import { handleInboxMessage } from "./inbound.js";
 import { displayPrefix } from "./config.js";
+import { buildHubWebSocketUrl } from "./hub-url.js";
 
 interface WsClientOptions {
   client: BotCordClient;
@@ -73,7 +74,7 @@ export function startWsClient(opts: WsClientOptions): { stop: () => void } {
       // Get a fresh JWT token
       const token = await client.ensureToken();
       const hubUrl = client.getHubUrl();
-      const wsUrl = hubUrl.replace(/^http/, "ws") + "/hub/ws";
+      const wsUrl = buildHubWebSocketUrl(hubUrl);
 
       log?.info(`[${dp}] WebSocket connecting to ${wsUrl}`);
       ws = new WebSocket(wsUrl);
@@ -184,4 +185,3 @@ export function stopWsClient(accountId: string): void {
   const entry = activeWsClients.get(accountId);
   if (entry) entry.stop();
 }
-