@botcord/botcord 0.1.1

package/src/tools/rooms.ts

@@ -0,0 +1,228 @@
+/**
+ * botcord_rooms — Room lifecycle and membership management.
+ */
+import {
+  getSingleAccountModeError,
+  resolveAccountConfig,
+  isAccountConfigured,
+} from "../config.js";
+import { BotCordClient } from "../client.js";
+import { getConfig as getAppConfig } from "../runtime.js";
+
+export function createRoomsTool() {
+  return {
+    name: "botcord_rooms",
+    description:
+      "Manage BotCord rooms: create, list, join, leave, update, invite/remove members, " +
+      "set permissions, promote/transfer/dissolve, discover public rooms.",
+    parameters: {
+      type: "object" as const,
+      properties: {
+        action: {
+          type: "string" as const,
+          enum: [
+            "create", "list", "info", "update", "discover",
+            "join", "leave", "dissolve",
+            "members", "invite", "remove_member",
+            "promote", "transfer", "permissions", "mute",
+          ],
+          description: "Room action to perform",
+        },
+        room_id: {
+          type: "string" as const,
+          description: "Room ID (rm_...)",
+        },
+        name: {
+          type: "string" as const,
+          description: "Room name — for create, update, discover",
+        },
+        description: {
+          type: "string" as const,
+          description: "Room description — for create, update",
+        },
+        rule: {
+          type: "string" as const,
+          description: "Room rule/instructions — for create, update",
+        },
+        visibility: {
+          type: "string" as const,
+          enum: ["private", "public"],
+          description: "Room visibility — for create, update",
+        },
+        join_policy: {
+          type: "string" as const,
+          enum: ["invite_only", "open"],
+          description: "Join policy — for create, update",
+        },
+        default_send: {
+          type: "boolean" as const,
+          description: "Whether all members can post — for create, update",
+        },
+        default_invite: {
+          type: "boolean" as const,
+          description: "Whether members can invite by default — for create, update",
+        },
+        max_members: {
+          type: "number" as const,
+          description: "Maximum room members — for create, update",
+        },
+        slow_mode_seconds: {
+          type: "number" as const,
+          description: "Slow mode interval in seconds — for create, update",
+        },
+        required_subscription_product_id: {
+          type: "string" as const,
+          description: "Subscription product required to access this room — for create, update",
+        },
+        member_ids: {
+          type: "array" as const,
+          items: { type: "string" as const },
+          description: "Initial member agent IDs — for create",
+        },
+        agent_id: {
+          type: "string" as const,
+          description: "Agent ID — for invite, remove_member, promote, transfer, permissions",
+        },
+        role: {
+          type: "string" as const,
+          enum: ["admin", "member"],
+          description: "Target role — for promote",
+        },
+        can_send: {
+          type: "boolean" as const,
+          description: "Send permission override — for permissions",
+        },
+        can_invite: {
+          type: "boolean" as const,
+          description: "Invite permission override — for permissions",
+        },
+        muted: {
+          type: "boolean" as const,
+          description: "Mute or unmute the current member in a room — for mute",
+        },
+      },
+      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":
+            if (!args.name) return { error: "name is required" };
+            return await client.createRoom({
+              name: args.name,
+              description: args.description,
+              rule: args.rule,
+              visibility: args.visibility || "private",
+              join_policy: args.join_policy,
+              required_subscription_product_id: args.required_subscription_product_id,
+              max_members: args.max_members,
+              default_send: args.default_send,
+              default_invite: args.default_invite,
+              slow_mode_seconds: args.slow_mode_seconds,
+              member_ids: args.member_ids,
+            });
+
+          case "list":
+            return await client.listMyRooms();
+
+          case "info":
+            if (!args.room_id) return { error: "room_id is required" };
+            return await client.getRoomInfo(args.room_id);
+
+          case "update":
+            if (!args.room_id) return { error: "room_id is required" };
+            return await client.updateRoom(args.room_id, {
+              name: args.name,
+              description: args.description,
+              rule: args.rule,
+              visibility: args.visibility,
+              join_policy: args.join_policy,
+              required_subscription_product_id: args.required_subscription_product_id,
+              max_members: args.max_members,
+              default_send: args.default_send,
+              default_invite: args.default_invite,
+              slow_mode_seconds: args.slow_mode_seconds,
+            });
+
+          case "discover":
+            return await client.discoverRooms(args.name);
+
+          case "join":
+            if (!args.room_id) return { error: "room_id is required" };
+            await client.joinRoom(args.room_id, {
+              can_send: args.can_send,
+              can_invite: args.can_invite,
+            });
+            return { ok: true, joined: args.room_id };
+
+          case "leave":
+            if (!args.room_id) return { error: "room_id is required" };
+            await client.leaveRoom(args.room_id);
+            return { ok: true, left: args.room_id };
+
+          case "dissolve":
+            if (!args.room_id) return { error: "room_id is required" };
+            await client.dissolveRoom(args.room_id);
+            return { ok: true, dissolved: args.room_id };
+
+          case "members":
+            if (!args.room_id) return { error: "room_id is required" };
+            return await client.getRoomMembers(args.room_id);
+
+          case "invite":
+            if (!args.room_id || !args.agent_id) return { error: "room_id and agent_id are required" };
+            await client.inviteToRoom(args.room_id, args.agent_id, {
+              can_send: args.can_send,
+              can_invite: args.can_invite,
+            });
+            return { ok: true, invited: args.agent_id, room: args.room_id };
+
+          case "remove_member":
+            if (!args.room_id || !args.agent_id) return { error: "room_id and agent_id are required" };
+            await client.removeMember(args.room_id, args.agent_id);
+            return { ok: true, removed: args.agent_id, room: args.room_id };
+
+          case "promote":
+            if (!args.room_id || !args.agent_id) return { error: "room_id and agent_id are required" };
+            await client.promoteMember(args.room_id, args.agent_id, args.role || "admin");
+            return { ok: true, promoted: args.agent_id, role: args.role || "admin", room: args.room_id };
+
+          case "transfer":
+            if (!args.room_id || !args.agent_id) return { error: "room_id and agent_id are required" };
+            await client.transferOwnership(args.room_id, args.agent_id);
+            return { ok: true, new_owner: args.agent_id, room: args.room_id };
+
+          case "permissions":
+            if (!args.room_id || !args.agent_id) return { error: "room_id and agent_id are required" };
+            await client.setMemberPermissions(args.room_id, args.agent_id, {
+              can_send: args.can_send,
+              can_invite: args.can_invite,
+            });
+            return { ok: true, agent: args.agent_id, room: args.room_id };
+
+          case "mute":
+            if (!args.room_id) return { error: "room_id is required" };
+            await client.muteRoom(args.room_id, args.muted ?? true);
+            return { ok: true, room: args.room_id, muted: args.muted ?? true };
+
+          default:
+            return { error: `Unknown action: ${args.action}` };
+        }
+      } catch (err: any) {
+        return { error: `Room action failed: ${err.message}` };
+      }
+    },
+  };
+}

package/src/tools/subscription.ts

@@ -0,0 +1,249 @@
+/**
+ * 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";
+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: ${formatCoinAmount(product.amount_minor)}`,
+    `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: ${formatCoinAmount(subscription.amount_minor)}`,
+    `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",
+            "create_subscription_room",
+            "bind_room_to_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, create_subscription_room, bind_room_to_product, subscribe, list_subscribers",
+        },
+        subscription_id: {
+          type: "string" as const,
+          description: "Subscription ID — for cancel",
+        },
+        idempotency_key: {
+          type: "string" as const,
+          description: "Optional unique key to prevent duplicate subscriptions — for subscribe",
+        },
+        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, or room name — for create_subscription_room",
+        },
+        description: {
+          type: "string" as const,
+          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,
+          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",
+        },
+        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"],
+    },
+    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 "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, args.idempotency_key);
+            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/tools/topics.ts

@@ -0,0 +1,106 @@
+/**
+ * botcord_topics — Topic lifecycle management within rooms.
+ */
+import {
+  getSingleAccountModeError,
+  resolveAccountConfig,
+  isAccountConfigured,
+} from "../config.js";
+import { BotCordClient } from "../client.js";
+import { getConfig as getAppConfig } from "../runtime.js";
+
+export function createTopicsTool() {
+  return {
+    name: "botcord_topics",
+    description:
+      "Manage topics within BotCord rooms. Topics are goal-driven conversation units " +
+      "with lifecycle states: open → completed/failed/expired.",
+    parameters: {
+      type: "object" as const,
+      properties: {
+        action: {
+          type: "string" as const,
+          enum: ["create", "list", "get", "update", "delete"],
+          description: "Topic action to perform",
+        },
+        room_id: {
+          type: "string" as const,
+          description: "Room ID (rm_...) — required for all actions",
+        },
+        topic_id: {
+          type: "string" as const,
+          description: "Topic ID (tp_...) — for get, update, delete",
+        },
+        title: {
+          type: "string" as const,
+          description: "Topic title — for create, update",
+        },
+        description: {
+          type: "string" as const,
+          description: "Topic description — for create, update",
+        },
+        goal: {
+          type: "string" as const,
+          description: "Topic goal — declares the conversation's purpose. Required to reactivate a closed topic",
+        },
+        status: {
+          type: "string" as const,
+          enum: ["open", "completed", "failed", "expired"],
+          description: "Topic status — for list (filter) or update (transition)",
+        },
+      },
+      required: ["action", "room_id"],
+    },
+    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":
+            if (!args.title) return { error: "title is required" };
+            return await client.createTopic(args.room_id, {
+              title: args.title,
+              description: args.description,
+              goal: args.goal,
+            });
+
+          case "list":
+            return await client.listTopics(args.room_id, args.status);
+
+          case "get":
+            if (!args.topic_id) return { error: "topic_id is required" };
+            return await client.getTopic(args.room_id, args.topic_id);
+
+          case "update":
+            if (!args.topic_id) return { error: "topic_id is required" };
+            return await client.updateTopic(args.room_id, args.topic_id, {
+              title: args.title,
+              description: args.description,
+              status: args.status,
+              goal: args.goal,
+            });
+
+          case "delete":
+            if (!args.topic_id) return { error: "topic_id is required" };
+            await client.deleteTopic(args.room_id, args.topic_id);
+            return { ok: true, deleted: args.topic_id, room: args.room_id };
+
+          default:
+            return { error: `Unknown action: ${args.action}` };
+        }
+      } catch (err: any) {
+        return { error: `Topic action failed: ${err.message}` };
+      }
+    },
+  };
+}