@moltium/core 0.1.4 → 0.1.6

package/dist/index.mjs

@@ -536,7 +536,7 @@ var MoltbookAdapter = class extends SocialAdapter {
     super();
     this.config = config;
     this.client = axios.create({
-      baseURL: config.baseUrl || "https://api.moltbook.com",
+      baseURL: config.baseUrl || "https://www.moltbook.com/api/v1",
       headers: {
         Authorization: `Bearer ${config.apiKey}`,
         "Content-Type": "application/json"
@@ -544,12 +544,18 @@ var MoltbookAdapter = class extends SocialAdapter {
     });
   }
   async connect() {
-    await this.client.get("/me");
+    await this.client.get("/agents/me");
   }
   async disconnect() {
   }
   async post(content) {
-    const response = await this.client.post("/posts", { content });
+    const submolt = this.config.defaultSubmolt || "general";
+    const title = extractTitle(content);
+    const response = await this.client.post("/posts", {
+      submolt,
+      title,
+      content
+    });
     return {
       id: response.data.id,
       url: response.data.url,
@@ -557,7 +563,7 @@ var MoltbookAdapter = class extends SocialAdapter {
     };
   }
   async reply(postId, content) {
-    const response = await this.client.post(`/posts/${postId}/replies`, { content });
+    const response = await this.client.post(`/posts/${postId}/comments`, { content });
     return {
       id: response.data.id,
       parentId: postId,
@@ -566,44 +572,48 @@ var MoltbookAdapter = class extends SocialAdapter {
     };
   }
   async like(postId) {
-    await this.client.post(`/posts/${postId}/like`);
+    await this.client.post(`/posts/${postId}/upvote`);
   }
-  async follow(userId) {
-    await this.client.post(`/users/${userId}/follow`);
+  async follow(agentName) {
+    await this.client.post(`/agents/${agentName}/follow`);
   }
   async getMentions() {
-    const response = await this.client.get("/mentions");
-    return response.data.mentions.map((m) => ({
+    const response = await this.client.get("/feed", {
+      params: { sort: "new", limit: 20 }
+    });
+    return (response.data.posts || []).map((m) => ({
       id: m.id,
-      authorId: m.author_id,
-      authorName: m.author_name,
+      authorId: m.author_id || m.author?.id || "",
+      authorName: m.author_name || m.author?.name || "",
       content: m.content,
       timestamp: new Date(m.created_at),
       platform: "moltbook"
     }));
   }
   async getFeed(options) {
-    const params = {};
+    const params = { sort: "hot" };
     if (options?.limit) params.limit = options.limit;
     if (options?.cursor) params.cursor = options.cursor;
     if (options?.since) params.since = options.since.toISOString();
     const response = await this.client.get("/feed", { params });
-    return response.data.posts.map((p) => ({
+    return (response.data.posts || []).map((p) => ({
       id: p.id,
-      authorId: p.author_id,
-      authorName: p.author_name,
+      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.likes_count,
-      replies: p.replies_count,
+      likes: p.upvotes ?? p.likes_count,
+      replies: p.comment_count ?? p.replies_count,
       reposts: p.reposts_count,
       mentions: p.mentions || [],
       url: p.url
     }));
   }
-  async getProfile(userId) {
-    const response = await this.client.get(`/users/${userId}`);
+  async getProfile(agentName) {
+    const response = await this.client.get("/agents/profile", {
+      params: { name: agentName }
+    });
     return {
       id: response.data.id,
       name: response.data.name,
@@ -614,6 +624,14 @@ var MoltbookAdapter = class extends SocialAdapter {
     };
   }
 };
+function extractTitle(content) {
+  const firstLine = content.split("\n")[0].trim();
+  const sentenceEnd = firstLine.search(/[.!?]/);
+  const raw = sentenceEnd > 0 && sentenceEnd <= 80 ? firstLine.slice(0, sentenceEnd + 1) : firstLine;
+  if (raw.length <= 80) return raw;
+  const truncated = raw.slice(0, 80).replace(/\s+\S*$/, "");
+  return truncated + "...";
+}
 
 // src/social/twitter.ts
 var TwitterAdapter = class extends SocialAdapter {
@@ -794,6 +812,7 @@ var Agent = class {
     if (this.hooks.onInit) {
       await this.hooks.onInit(this);
     }
+    await this.postStartupMessages();
     logger4.info(`Agent initialized: ${this.config.name}`);
   }
   async start() {
@@ -924,40 +943,114 @@ var Agent = class {
   }
   async initSocialAdapters() {
     const { social } = this.config;
+    const configuredPlatforms = Object.keys(social).filter(
+      (k) => social[k] && typeof social[k] === "object"
+    );
+    if (configuredPlatforms.length === 0) {
+      logger4.warn("Social: No platforms configured. To post on startup, add a social platform to your config.");
+      logger4.warn('  Code-based: Add a moltbook or twitter section to agent.config.ts under "social".');
+      logger4.warn('  Markdown: Add a "### Moltbook" section under "## Social Platforms" in agent.md with "enabled: true".');
+      return;
+    }
+    logger4.info(`Social: Found platforms in config: ${configuredPlatforms.join(", ")}`);
     if (social.moltbook?.enabled) {
+      const baseUrl = social.moltbook.baseUrl || "https://www.moltbook.com/api/v1";
       if (!social.moltbook.apiKey || social.moltbook.apiKey === "your-moltbook-key-here") {
-        logger4.error("Moltbook is enabled but MOLTBOOK_API_KEY is missing or still a placeholder. Set a valid key in your .env file.");
+        logger4.error("Moltbook: SKIPPED \u2014 MOLTBOOK_API_KEY is missing or still a placeholder.");
+        logger4.error("  Fix: Set a valid MOLTBOOK_API_KEY in your .env file.");
       } else {
+        logger4.info(`Moltbook: Connecting to ${baseUrl} ...`);
         const adapter = new MoltbookAdapter(social.moltbook);
         try {
           await adapter.connect();
           this.socialAdapters["moltbook"] = adapter;
-          logger4.info("Moltbook adapter connected");
+          logger4.info("Moltbook: Connected successfully (GET /agents/me OK)");
         } catch (error) {
-          logger4.error(`Failed to connect Moltbook adapter: ${error.message || error}`);
-          if (error.response) {
-            logger4.error(`  HTTP ${error.response.status}: ${JSON.stringify(error.response.data)}`);
-          }
+          logger4.error(`Moltbook: Connection FAILED \u2014 ${error.message || error}`);
+          this.logPlatformError("Moltbook", error);
         }
       }
+    } else if (social.moltbook) {
+      logger4.warn('Moltbook: Present in config but disabled (enabled: false). Set "enabled: true" to activate.');
     }
     if (social.twitter?.enabled) {
       const creds = social.twitter.credentials;
       if (!creds?.apiKey || creds.apiKey === "your-twitter-api-key") {
-        logger4.error("Twitter is enabled but credentials are missing or still placeholders. Set valid Twitter keys in your .env file.");
+        logger4.error("Twitter: SKIPPED \u2014 credentials are missing or still placeholders.");
+        logger4.error("  Fix: Set valid Twitter keys in your .env file.");
       } else {
+        logger4.info("Twitter: Connecting...");
         const adapter = new TwitterAdapter(social.twitter);
         try {
           await adapter.connect();
           this.socialAdapters["twitter"] = adapter;
-          logger4.info("Twitter adapter connected");
+          logger4.info("Twitter: Connected successfully");
         } catch (error) {
-          logger4.error(`Failed to connect Twitter adapter: ${error.message || error}`);
-          if (error.response) {
-            logger4.error(`  HTTP ${error.response.status}: ${JSON.stringify(error.response.data)}`);
-          }
+          logger4.error(`Twitter: Connection FAILED \u2014 ${error.message || error}`);
+          this.logPlatformError("Twitter", error);
         }
       }
+    } else if (social.twitter) {
+      logger4.warn('Twitter: Present in config but disabled (enabled: false). Set "enabled: true" to activate.');
+    }
+  }
+  async postStartupMessages() {
+    const adapters = Object.entries(this.socialAdapters);
+    if (adapters.length === 0) {
+      logger4.info("Startup post: No connected social adapters \u2014 skipping");
+      return;
+    }
+    const content = `${this.config.name} is now online and ready.`;
+    for (const [platform, adapter] of adapters) {
+      logger4.info(`Startup post: Posting to ${platform}...`);
+      try {
+        const result = await adapter.post(content);
+        logger4.info(`Startup post: ${platform} SUCCESS \u2014 id=${result.id}${result.url ? ` url=${result.url}` : ""}`);
+      } catch (error) {
+        logger4.error(`Startup post: ${platform} FAILED \u2014 ${error.message || error}`);
+        this.logPlatformError(platform, error);
+      }
+    }
+  }
+  logPlatformError(platform, error) {
+    if (!error.response) {
+      if (error.code === "ENOTFOUND") {
+        logger4.error(`  ${platform}: DNS lookup failed \u2014 check the base URL.`);
+      } else if (error.code === "ECONNREFUSED") {
+        logger4.error(`  ${platform}: Connection refused \u2014 is the server running?`);
+      } else if (error.code === "ETIMEDOUT" || error.code === "ECONNABORTED") {
+        logger4.error(`  ${platform}: Request timed out.`);
+      } else {
+        logger4.error(`  ${platform}: Network error (${error.code || "unknown"})`);
+      }
+      return;
+    }
+    const status = error.response.status;
+    const data = error.response.data;
+    logger4.error(`  ${platform}: HTTP ${status}`);
+    if (data) {
+      if (data.error) logger4.error(`  ${platform}: API error: ${data.error}`);
+      if (data.hint) logger4.error(`  ${platform}: API hint: ${data.hint}`);
+      if (!data.error && !data.hint) logger4.error(`  ${platform}: Response: ${JSON.stringify(data)}`);
+    }
+    if (status === 401) {
+      logger4.error(`  ${platform}: Your API key was rejected. Verify it is correct and the agent is claimed.`);
+    } else if (status === 403) {
+      logger4.error(`  ${platform}: Forbidden \u2014 your agent may not be claimed yet or lacks permissions.`);
+    } else if (status === 429) {
+      const retryMin = data?.retry_after_minutes;
+      const retrySec = data?.retry_after_seconds;
+      if (retryMin) {
+        logger4.error(`  ${platform}: Rate limited \u2014 try again in ${retryMin} minute(s).`);
+      } else if (retrySec) {
+        logger4.error(`  ${platform}: Rate limited \u2014 try again in ${retrySec} second(s).`);
+      } else {
+        logger4.error(`  ${platform}: Rate limited \u2014 wait before retrying.`);
+      }
+    } else if (status === 404) {
+      logger4.error(`  ${platform}: Endpoint not found \u2014 check the base URL.`);
+    } else if (status >= 500) {
+      logger4.error(`  ${platform}: Server error \u2014 the platform may be temporarily down.`);
     }
   }
   startAutonomousLoop() {
@@ -1097,8 +1190,10 @@ var MarkdownParser = class {
     for (const child of section.children) {
       const platform = child.title.toLowerCase();
       const fields = this.parseKeyValueLines(child.content);
+      const enabled = fields["enabled"] === "true";
+      delete fields["enabled"];
       social[platform] = {
-        enabled: fields["enabled"] === "true",
+        enabled,
         ...fields
       };
     }
@@ -1528,6 +1623,13 @@ function createRoutes(agent) {
       timestamp: (/* @__PURE__ */ new Date()).toISOString()
     });
   });
+  router.get("/message", (_req, res) => {
+    res.status(405).json({
+      error: "Method Not Allowed",
+      message: "Use POST /message to send a message to the agent.",
+      expected_body: { message: "string" }
+    });
+  });
   router.post("/message", async (req, res) => {
     try {
       const { message } = req.body;
@@ -1544,6 +1646,13 @@ function createRoutes(agent) {
       res.status(500).json({ error: error instanceof Error ? error.message : "Unknown error" });
     }
   });
+  router.get("/action", (_req, res) => {
+    res.status(405).json({
+      error: "Method Not Allowed",
+      message: "Use POST /action to trigger an action.",
+      expected_body: { action: "string", parameters: "{}" }
+    });
+  });
   router.post("/action", async (req, res) => {
     try {
       const { action, parameters } = req.body;