@moltium/core 0.1.13 → 0.1.14

package/dist/index.mjs

@@ -525,6 +525,25 @@ import axios from "axios";
 
 // src/social/SocialAdapter.ts
 var SocialAdapter = class {
+  // Optional methods with defaults — override in platform adapters as needed
+  async downvote(_id) {
+    throw new Error(`downvote() is not supported on ${this.platform}`);
+  }
+  async unfollow(_userId) {
+    throw new Error(`unfollow() is not supported on ${this.platform}`);
+  }
+  async getPost(_id) {
+    throw new Error(`getPost() is not supported on ${this.platform}`);
+  }
+  async deletePost(_id) {
+    throw new Error(`deletePost() is not supported on ${this.platform}`);
+  }
+  async getComments(_postId, _sort) {
+    throw new Error(`getComments() is not supported on ${this.platform}`);
+  }
+  async search(_query, _options) {
+    throw new Error(`search() is not supported on ${this.platform}`);
+  }
 };
 
 // src/social/moltbook.ts
@@ -543,11 +562,61 @@ var MoltbookAdapter = class extends SocialAdapter {
       }
     });
   }
+  // ── Connection ──
   async connect() {
     await this.client.get("/agents/me");
   }
   async disconnect() {
   }
+  // ── Registration & Status ──
+  async register(name, description) {
+    const response = await this.client.post("/agents/register", { name, description });
+    const agent = response.data.agent || response.data;
+    return {
+      apiKey: agent.api_key,
+      claimUrl: agent.claim_url,
+      verificationCode: agent.verification_code
+    };
+  }
+  async getStatus() {
+    const response = await this.client.get("/agents/status");
+    return { status: response.data.status };
+  }
+  // ── Profile ──
+  async getProfile(agentName) {
+    const response = await this.client.get("/agents/profile", {
+      params: { name: agentName }
+    });
+    const agent = response.data.agent || response.data;
+    return {
+      id: agent.id || agent.name,
+      name: agent.name,
+      bio: agent.description,
+      followers: agent.follower_count,
+      following: agent.following_count,
+      platform: "moltbook"
+    };
+  }
+  async getMyProfile() {
+    const response = await this.client.get("/agents/me");
+    return response.data;
+  }
+  async updateProfile(data) {
+    await this.client.patch("/agents/me", data);
+  }
+  async uploadAvatar(filePath) {
+    const fs = await import("fs");
+    const FormData = (await import("form-data")).default;
+    const form = new FormData();
+    form.append("file", fs.createReadStream(filePath));
+    await this.client.post("/agents/me/avatar", form, {
+      headers: { ...form.getHeaders(), Authorization: `Bearer ${this.config.apiKey}` }
+    });
+  }
+  async deleteAvatar() {
+    await this.client.delete("/agents/me/avatar");
+  }
+  // ── Posts ──
   async post(content) {
     const submolt = this.config.defaultSubmolt || "general";
     const title = extractTitle(content);
@@ -562,6 +631,35 @@ var MoltbookAdapter = class extends SocialAdapter {
       timestamp: new Date(response.data.created_at)
     };
   }
+  async postLink(submolt, title, url) {
+    const response = await this.client.post("/posts", { submolt, title, url });
+    return {
+      id: response.data.id,
+      url: response.data.url,
+      timestamp: new Date(response.data.created_at)
+    };
+  }
+  async getPost(postId) {
+    const response = await this.client.get(`/posts/${postId}`);
+    const p = response.data.post || response.data;
+    return {
+      id: p.id,
+      authorId: p.author_id || p.author?.id || "",
+      authorName: p.author_name || p.author?.name || "",
+      content: p.content,
+      title: p.title,
+      timestamp: new Date(p.created_at),
+      platform: "moltbook",
+      likes: p.upvotes ?? p.likes_count,
+      replies: p.comment_count ?? p.replies_count,
+      url: p.url,
+      submolt: p.submolt?.name || p.submolt
+    };
+  }
+  async deletePost(postId) {
+    await this.client.delete(`/posts/${postId}`);
+  }
+  // ── Comments ──
   async reply(postId, content) {
     const response = await this.client.post(`/posts/${postId}/comments`, { content });
     return {
@@ -571,12 +669,43 @@ var MoltbookAdapter = class extends SocialAdapter {
       timestamp: new Date(response.data.created_at)
     };
   }
+  async replyToComment(postId, content, parentId) {
+    const response = await this.client.post(`/posts/${postId}/comments`, {
+      content,
+      parent_id: parentId
+    });
+    return {
+      id: response.data.id,
+      parentId,
+      url: response.data.url,
+      timestamp: new Date(response.data.created_at)
+    };
+  }
+  async getComments(postId, sort = "top") {
+    const response = await this.client.get(`/posts/${postId}/comments`, {
+      params: { sort }
+    });
+    const items = response.data.comments || response.data || [];
+    return items.map((c) => mapComment(c, postId));
+  }
+  async upvoteComment(commentId) {
+    await this.client.post(`/comments/${commentId}/upvote`);
+  }
+  // ── Voting ──
   async like(postId) {
     await this.client.post(`/posts/${postId}/upvote`);
   }
+  async downvote(postId) {
+    await this.client.post(`/posts/${postId}/downvote`);
+  }
+  // ── Following ──
   async follow(agentName) {
     await this.client.post(`/agents/${agentName}/follow`);
   }
+  async unfollow(agentName) {
+    await this.client.delete(`/agents/${agentName}/follow`);
+  }
+  // ── Feed ──
   async getMentions() {
     const response = await this.client.get("/feed", {
       params: { sort: "new", limit: 20 }
@@ -591,38 +720,225 @@ var MoltbookAdapter = class extends SocialAdapter {
     }));
   }
   async getFeed(options) {
-    const params = { sort: "hot" };
+    const params = { sort: options?.sort || "hot" };
     if (options?.limit) params.limit = options.limit;
     if (options?.cursor) params.cursor = options.cursor;
     if (options?.since) params.since = options.since.toISOString();
+    if (options?.submolt) params.submolt = options.submolt;
     const response = await this.client.get("/feed", { params });
-    return (response.data.posts || []).map((p) => ({
-      id: p.id,
-      authorId: p.author_id || p.author?.id || "",
-      authorName: p.author_name || p.author?.name || "",
-      content: p.content,
-      timestamp: new Date(p.created_at),
-      platform: "moltbook",
-      likes: p.upvotes ?? p.likes_count,
-      replies: p.comment_count ?? p.replies_count,
-      reposts: p.reposts_count,
-      mentions: p.mentions || [],
-      url: p.url
+    return (response.data.posts || []).map((p) => mapPost(p));
+  }
+  async getGlobalFeed(options) {
+    const params = { sort: options?.sort || "hot" };
+    if (options?.limit) params.limit = options.limit;
+    if (options?.submolt) params.submolt = options.submolt;
+    const response = await this.client.get("/posts", { params });
+    return (response.data.posts || []).map((p) => mapPost(p));
+  }
+  // ── Search ──
+  async search(query, options) {
+    const params = { q: query };
+    if (options?.type) params.type = options.type;
+    if (options?.limit) params.limit = options.limit;
+    const response = await this.client.get("/search", { params });
+    return (response.data.results || []).map((r) => ({
+      id: r.id,
+      type: r.type,
+      title: r.title,
+      content: r.content,
+      upvotes: r.upvotes ?? 0,
+      downvotes: r.downvotes ?? 0,
+      similarity: r.similarity,
+      author: { name: r.author?.name || "" },
+      submolt: r.submolt,
+      postId: r.post_id || r.id,
+      timestamp: new Date(r.created_at)
     }));
   }
-  async getProfile(agentName) {
-    const response = await this.client.get("/agents/profile", {
-      params: { name: agentName }
+  // ── Submolts (Communities) ──
+  async createSubmolt(name, displayName, description) {
+    const response = await this.client.post("/submolts", {
+      name,
+      display_name: displayName,
+      description
     });
+    const s = response.data.submolt || response.data;
+    return mapSubmolt(s);
+  }
+  async listSubmolts() {
+    const response = await this.client.get("/submolts");
+    const items = response.data.submolts || response.data || [];
+    return items.map((s) => mapSubmolt(s));
+  }
+  async getSubmolt(name) {
+    const response = await this.client.get(`/submolts/${name}`);
+    const s = response.data.submolt || response.data;
+    return mapSubmolt(s);
+  }
+  async subscribe(submoltName) {
+    await this.client.post(`/submolts/${submoltName}/subscribe`);
+  }
+  async unsubscribe(submoltName) {
+    await this.client.delete(`/submolts/${submoltName}/subscribe`);
+  }
+  async getSubmoltFeed(submoltName, sort = "hot", limit = 25) {
+    const response = await this.client.get(`/submolts/${submoltName}/feed`, {
+      params: { sort, limit }
+    });
+    return (response.data.posts || []).map((p) => mapPost(p));
+  }
+  // ── Moderation ──
+  async pinPost(postId) {
+    await this.client.post(`/posts/${postId}/pin`);
+  }
+  async unpinPost(postId) {
+    await this.client.delete(`/posts/${postId}/pin`);
+  }
+  async updateSubmoltSettings(submoltName, settings) {
+    const payload = {};
+    if (settings.description !== void 0) payload.description = settings.description;
+    if (settings.bannerColor !== void 0) payload.banner_color = settings.bannerColor;
+    if (settings.themeColor !== void 0) payload.theme_color = settings.themeColor;
+    await this.client.patch(`/submolts/${submoltName}/settings`, payload);
+  }
+  async uploadSubmoltAvatar(submoltName, filePath) {
+    const fs = await import("fs");
+    const FormData = (await import("form-data")).default;
+    const form = new FormData();
+    form.append("file", fs.createReadStream(filePath));
+    form.append("type", "avatar");
+    await this.client.post(`/submolts/${submoltName}/settings`, form, {
+      headers: { ...form.getHeaders(), Authorization: `Bearer ${this.config.apiKey}` }
+    });
+  }
+  async uploadSubmoltBanner(submoltName, filePath) {
+    const fs = await import("fs");
+    const FormData = (await import("form-data")).default;
+    const form = new FormData();
+    form.append("file", fs.createReadStream(filePath));
+    form.append("type", "banner");
+    await this.client.post(`/submolts/${submoltName}/settings`, form, {
+      headers: { ...form.getHeaders(), Authorization: `Bearer ${this.config.apiKey}` }
+    });
+  }
+  async addModerator(submoltName, agentName, role = "moderator") {
+    await this.client.post(`/submolts/${submoltName}/moderators`, {
+      agent_name: agentName,
+      role
+    });
+  }
+  async removeModerator(submoltName, agentName) {
+    await this.client.delete(`/submolts/${submoltName}/moderators`, {
+      data: { agent_name: agentName }
+    });
+  }
+  async listModerators(submoltName) {
+    const response = await this.client.get(`/submolts/${submoltName}/moderators`);
+    return response.data.moderators || response.data || [];
+  }
+  // ── DM / Private Messaging ──
+  async checkDMs() {
+    const response = await this.client.get("/agents/dm/check");
+    const d = response.data;
     return {
-      id: response.data.id,
-      name: response.data.name,
-      bio: response.data.bio,
-      followers: response.data.followers_count,
-      following: response.data.following_count,
-      platform: "moltbook"
+      hasActivity: d.has_activity,
+      summary: d.summary || "",
+      requests: {
+        count: d.requests?.count || 0,
+        items: (d.requests?.items || []).map((r) => ({
+          conversationId: r.conversation_id,
+          from: {
+            name: r.from?.name || "",
+            owner: r.from?.owner ? {
+              xHandle: r.from.owner.x_handle,
+              xName: r.from.owner.x_name
+            } : void 0
+          },
+          messagePreview: r.message_preview || "",
+          createdAt: new Date(r.created_at)
+        }))
+      },
+      messages: {
+        totalUnread: d.messages?.total_unread || 0,
+        conversationsWithUnread: d.messages?.conversations_with_unread || 0,
+        latest: d.messages?.latest || []
+      }
     };
   }
+  async sendDMRequest(to, message, byOwner = false) {
+    const payload = { message };
+    if (byOwner) {
+      payload.to_owner = to;
+    } else {
+      payload.to = to;
+    }
+    const response = await this.client.post("/agents/dm/request", payload);
+    return { conversationId: response.data.conversation_id || response.data.id };
+  }
+  async getDMRequests() {
+    const response = await this.client.get("/agents/dm/requests");
+    const items = response.data.requests || response.data || [];
+    return items.map((r) => ({
+      conversationId: r.conversation_id,
+      from: {
+        name: r.from?.name || "",
+        owner: r.from?.owner ? {
+          xHandle: r.from.owner.x_handle,
+          xName: r.from.owner.x_name
+        } : void 0
+      },
+      messagePreview: r.message_preview || r.message || "",
+      createdAt: new Date(r.created_at)
+    }));
+  }
+  async approveDMRequest(conversationId) {
+    await this.client.post(`/agents/dm/requests/${conversationId}/approve`);
+  }
+  async rejectDMRequest(conversationId, block = false) {
+    const payload = block ? { block: true } : void 0;
+    await this.client.post(`/agents/dm/requests/${conversationId}/reject`, payload);
+  }
+  async listConversations() {
+    const response = await this.client.get("/agents/dm/conversations");
+    const items = response.data.conversations?.items || response.data.conversations || [];
+    return items.map((c) => ({
+      conversationId: c.conversation_id,
+      withAgent: {
+        name: c.with_agent?.name || "",
+        description: c.with_agent?.description,
+        karma: c.with_agent?.karma,
+        owner: c.with_agent?.owner ? {
+          xHandle: c.with_agent.owner.x_handle,
+          xName: c.with_agent.owner.x_name
+        } : void 0
+      },
+      unreadCount: c.unread_count || 0,
+      lastMessageAt: new Date(c.last_message_at),
+      youInitiated: c.you_initiated ?? false
+    }));
+  }
+  async readConversation(conversationId) {
+    const response = await this.client.get(`/agents/dm/conversations/${conversationId}`);
+    const d = response.data;
+    return {
+      conversationId: d.conversation_id || conversationId,
+      withAgent: { name: d.with_agent?.name || "" },
+      messages: (d.messages || []).map((m) => ({
+        id: m.id,
+        sender: m.sender || m.from || "",
+        content: m.content || m.message || "",
+        timestamp: new Date(m.created_at || m.timestamp),
+        needsHumanInput: m.needs_human_input
+      }))
+    };
+  }
+  async sendDM(conversationId, message, needsHumanInput = false) {
+    const payload = { message };
+    if (needsHumanInput) {
+      payload.needs_human_input = true;
+    }
+    await this.client.post(`/agents/dm/conversations/${conversationId}/send`, payload);
+  }
 };
 function extractTitle(content) {
   const firstLine = content.split("\n")[0].trim();
@@ -632,6 +948,47 @@ function extractTitle(content) {
   const truncated = raw.slice(0, 80).replace(/\s+\S*$/, "");
   return truncated + "...";
 }
+function mapPost(p) {
+  return {
+    id: p.id,
+    authorId: p.author_id || p.author?.id || "",
+    authorName: p.author_name || p.author?.name || "",
+    content: p.content,
+    title: p.title,
+    timestamp: new Date(p.created_at),
+    platform: "moltbook",
+    likes: p.upvotes ?? p.likes_count,
+    replies: p.comment_count ?? p.replies_count,
+    reposts: p.reposts_count,
+    mentions: p.mentions || [],
+    url: p.url,
+    submolt: p.submolt?.name || p.submolt
+  };
+}
+function mapComment(c, postId) {
+  return {
+    id: c.id,
+    postId,
+    parentId: c.parent_id,
+    authorName: c.author?.name || c.author_name || "",
+    content: c.content,
+    upvotes: c.upvotes ?? 0,
+    downvotes: c.downvotes ?? 0,
+    timestamp: new Date(c.created_at),
+    replies: c.replies?.map((r) => mapComment(r, postId))
+  };
+}
+function mapSubmolt(s) {
+  return {
+    name: s.name,
+    displayName: s.display_name || s.name,
+    description: s.description || "",
+    subscriberCount: s.subscriber_count || 0,
+    postCount: s.post_count,
+    yourRole: s.your_role || null,
+    createdAt: new Date(s.created_at)
+  };
+}
 
 // src/social/twitter.ts
 var TwitterAdapter = class extends SocialAdapter {