openclaw-quiubo 2.6.27 → 2.6.29

package/README.md

@@ -145,28 +145,25 @@ On first gateway startup, if the bot has no groups, the plugin automatically cre
 
 Run multiple AI agents on a single OpenClaw gateway — each with their own Quiubo chat, workspace, model, and cron jobs.
 
-### Step 1: Add the agent
+Each agent needs two things: a **bot identity** in Quiubo (so it has its own chat presence) and an **agent entry** in OpenClaw (so it has its own workspace and model). They can share the same SDK API key.
 
-In `~/.openclaw/openclaw.json`:
+### Step 1: Create a bot identity in Quiubo
 
-```json
-{
-  "agents": {
-    "list": [
-      { "id": "main" },
-      {
-        "id": "project-manager",
-        "model": "anthropic/claude-sonnet-4-5",
-        "workspace": "~/.openclaw/workspace-project-manager"
-      }
-    ]
-  }
-}
+Each agent needs its own bot identity. You create one by running the setup wizard with a new account ID:
+
+```bash
+openclaw channels add --channel quiubo
 ```
 
-### Step 2: Add a Quiubo account for the agent
+The wizard will:
+
+1. Ask for an **Account ID** — enter a short name for this agent (e.g. `pm`, `support`, `research`). Your first/default agent uses `default`.
+2. Ask for your **SDK API Key** — you can reuse the same `qub_...` key across all agents.
+3. **Create or select a bot identity** — choose "Create new bot identity" to give this agent its own username and display name in Quiubo.
 
-Each account needs its own bot identity (can share the same API key):
+> **Where to get an SDK API Key:** In the Quiubo app, go to **Settings > Developer > API Keys**. One key works for all agents under the same app.
+
+After the wizard completes, the new account is saved to `~/.openclaw/openclaw.json` automatically:
 
 ```json
 {
@@ -174,11 +171,11 @@ Each account needs its own bot identity (can share the same API key):
     "quiubo": {
       "accounts": {
         "default": {
-          "sdkApiKey": "qub_...",
+          "apiKey": "qub_...",
           "botIdentityId": "<main-bot-uuid>"
         },
         "pm": {
-          "sdkApiKey": "qub_...",
+          "apiKey": "qub_...",
           "botIdentityId": "<pm-bot-uuid>"
         }
       }
@@ -187,7 +184,30 @@ Each account needs its own bot identity (can share the same API key):
 }
 ```
 
-### Step 3: Bind accounts to agents
+### Step 2: Add the agent to OpenClaw
+
+In `~/.openclaw/openclaw.json`, add an entry to the agents list:
+
+```json
+{
+  "agents": {
+    "list": [
+      { "id": "main" },
+      {
+        "id": "project-manager",
+        "model": "anthropic/claude-sonnet-4-5",
+        "workspace": "~/.openclaw/workspace-project-manager"
+      }
+    ]
+  }
+}
+```
+
+Each agent can have its own model, workspace, and system prompt.
+
+### Step 3: Bind the Quiubo account to the agent
+
+Tell OpenClaw which Quiubo account maps to which agent:
 
 ```json
 {
@@ -233,6 +253,16 @@ Quiubo Chat (You + PM Bot)    → account: pm      → binding → agent: projec
 - **Workspaces**: Fully isolated — agents can't see each other's files
 - **Cursors**: Each account has its own cursor file — no clobbering
 
+### Adding more agents
+
+Repeat steps 1–5 for each new agent. The key command is:
+
+```bash
+openclaw channels add --channel quiubo
+```
+
+Enter a unique Account ID each time (e.g. `support`, `research`). The wizard handles identity creation and config — then add the agent, binding, and workspace as shown above.
+
 ## Markdown Attachments
 
 Agents can send `.md` file attachments alongside messages. Attachments appear as tappable cards in the Quiubo app with a full markdown viewer.

package/dist/index.js

@@ -9233,6 +9233,31 @@ var QuiuboApiClient = class {
       identity_id: identityId
     });
   }
+  // ========================================================================
+  // Attachment Upload
+  // ========================================================================
+  /**
+   * Get a presigned S3 URL for uploading an image attachment
+   */
+  async getAttachmentPresignUrl(groupId, opts) {
+    return this.request("POST", `/groups/${groupId}/attachments/presign`, opts);
+  }
+  /**
+   * Upload a file buffer to a presigned S3 URL
+   */
+  async uploadToPresignedUrl(uploadUrl, buffer, contentType) {
+    const response = await fetch(uploadUrl, {
+      method: "PUT",
+      headers: {
+        "Content-Type": contentType,
+        "Content-Length": String(buffer.length)
+      },
+      body: buffer
+    });
+    if (!response.ok) {
+      throw new Error(`S3 upload failed: ${response.status} ${response.statusText}`);
+    }
+  }
 };
 
 // src/realtime-gateway.ts
@@ -13300,23 +13325,57 @@ async function persistSeed(seedFile, seedB64) {
   } catch {
   }
 }
-async function readMdAttachments(mediaUrls, source, log, accountId) {
+var IMAGE_MIME_TYPES = {
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".png": "image/png",
+  ".webp": "image/webp"
+};
+var MAX_IMAGE_BYTES = 5 * 1024 * 1024;
+async function readOutboundAttachments(mediaUrls, source, client, groupId, log, accountId) {
   const attachments = [];
   const seen = /* @__PURE__ */ new Set();
   for (const url of mediaUrls) {
     if (seen.has(url)) continue;
     seen.add(url);
     const filename = basename(url);
-    if (!filename.endsWith(".md")) continue;
-    try {
-      const content = await readFile2(url, "utf-8");
-      if (content.length > 1024 * 1024) {
-        log?.warn?.(`[${accountId}] Quiubo: skipping ${filename} \u2014 exceeds 1MB`);
-        continue;
+    const ext = filename.substring(filename.lastIndexOf(".")).toLowerCase();
+    if (ext === ".md") {
+      try {
+        const content = await readFile2(url, "utf-8");
+        if (content.length > 1024 * 1024) {
+          log?.warn?.(`[${accountId}] Quiubo: skipping ${filename} \u2014 exceeds 1MB`);
+          continue;
+        }
+        attachments.push({ filename, mimeType: "text/markdown", content, source });
+      } catch (err) {
+        log?.warn?.(`[${accountId}] Quiubo: failed to read ${url}: ${err}`);
+      }
+    } else if (ext in IMAGE_MIME_TYPES) {
+      const mimeType = IMAGE_MIME_TYPES[ext];
+      try {
+        const buffer = await readFile2(url);
+        if (buffer.length > MAX_IMAGE_BYTES) {
+          log?.warn?.(`[${accountId}] Quiubo: skipping ${filename} \u2014 exceeds 5MB (${buffer.length} bytes)`);
+          continue;
+        }
+        const presign = await client.getAttachmentPresignUrl(groupId, {
+          contentType: mimeType,
+          contentLength: buffer.length,
+          filename
+        });
+        await client.uploadToPresignedUrl(presign.uploadUrl, buffer, mimeType);
+        attachments.push({
+          filename,
+          mimeType,
+          storageUrl: presign.storageUrl,
+          sizeBytes: buffer.length,
+          source
+        });
+        log?.info?.(`[${accountId}] Quiubo: uploaded image ${filename} (${buffer.length} bytes) \u2192 ${presign.storageUrl}`);
+      } catch (err) {
+        log?.warn?.(`[${accountId}] Quiubo: failed to upload image ${url}: ${err}`);
       }
-      attachments.push({ filename, mimeType: "text/markdown", content, source });
-    } catch (err) {
-      log?.warn?.(`[${accountId}] Quiubo: failed to read ${url}: ${err}`);
     }
   }
   return attachments;
@@ -13675,8 +13734,6 @@ var quiuboPlugin = {
       if (Array.isArray(ctx.mediaUrls)) urls.push(...ctx.mediaUrls);
       const accountId = ctx.accountId ?? DEFAULT_ACCOUNT_ID;
       const log = loggers.get(accountId);
-      const mdAttachments = await readMdAttachments(urls, "agent", log, accountId);
-      const plaintext = text || (mdAttachments.length === 0 ? "[Media attachment]" : "");
       let client = clients.get(accountId);
       let account = accounts.get(accountId);
       if (!client || !account) {
@@ -13695,23 +13752,37 @@ var quiuboPlugin = {
       if (!groupId) {
         groupId = await resolveAnnounceGroupId(accountId, log);
       }
-      log?.info?.(`[${accountId}] [outbound:sendMedia] groupId=${groupId}, urls=${urls.length}, attachments=${mdAttachments.length}`);
       if (!groupId) {
         log?.error?.(`[${accountId}] [outbound:sendMedia] no groupId \u2014 ctx keys=${Object.keys(ctx).join(",")}`);
         return { ok: false, error: "No groupId in outbound context" };
       }
+      const outboundAttachments = await readOutboundAttachments(urls, "agent", client, groupId, log, accountId);
+      const imageAttachments = outboundAttachments.filter((a) => a.mimeType.startsWith("image/"));
+      const nonImageAttachments = outboundAttachments.filter((a) => !a.mimeType.startsWith("image/"));
+      const plaintext = text || (outboundAttachments.length === 0 ? "[Media attachment]" : "");
+      log?.info?.(`[${accountId}] [outbound:sendMedia] groupId=${groupId}, urls=${urls.length}, attachments=${outboundAttachments.length} (${imageAttachments.length} images)`);
       const senderId = account.botIdentityId;
       if (!senderId) {
         return { ok: false, error: "No botIdentityId configured" };
       }
       try {
-        const apiResp = await client.sendMessage(groupId, {
-          senderIdentityId: senderId,
-          plaintext,
-          metadata: { format: "markdown" },
-          ...mdAttachments.length > 0 ? { attachments: mdAttachments } : {}
-        });
-        log?.info?.(`[${accountId}] [outbound:sendMedia] sent to group ${groupId} (realtime=${apiResp?.realtimeDelivered})`);
+        if (plaintext || nonImageAttachments.length > 0) {
+          const apiResp = await client.sendMessage(groupId, {
+            senderIdentityId: senderId,
+            plaintext: plaintext || " ",
+            metadata: { format: "markdown" },
+            ...nonImageAttachments.length > 0 ? { attachments: nonImageAttachments } : {}
+          });
+          log?.info?.(`[${accountId}] [outbound:sendMedia] sent to group ${groupId} (realtime=${apiResp?.realtimeDelivered})`);
+        }
+        for (const img of imageAttachments) {
+          const imgResp = await client.sendMessage(groupId, {
+            senderIdentityId: senderId,
+            plaintext: " ",
+            attachments: [img]
+          });
+          log?.info?.(`[${accountId}] [outbound:sendMedia] image ${img.filename} sent to group ${groupId} (realtime=${imgResp?.realtimeDelivered})`);
+        }
         return { ok: true };
       } catch (error) {
         if (error instanceof QuiuboApiError) {
@@ -14232,8 +14303,29 @@ async function routeInboundMessage(opts) {
   const imageAttachments = (msg.attachments ?? []).filter(
     (att) => att.storageUrl && att.mimeType?.startsWith("image/")
   );
-  const mediaUrls = imageAttachments.map((att) => att.storageUrl);
-  const mediaTypes = imageAttachments.map((att) => att.mimeType);
+  const mediaPaths = [];
+  const mediaTypes = [];
+  if (imageAttachments.length > 0) {
+    const mediaDir = join2(process.env.HOME ?? process.env.USERPROFILE ?? "", ".openclaw", "media", "inbound");
+    await mkdir2(mediaDir, { recursive: true });
+    for (const att of imageAttachments) {
+      try {
+        const resp = await fetch(att.storageUrl);
+        if (!resp.ok) {
+          log?.warn?.(`[${accountId}] Failed to download attachment ${att.filename}: ${resp.status}`);
+          continue;
+        }
+        const buffer = Buffer.from(await resp.arrayBuffer());
+        const ext = att.filename?.split(".").pop() || "png";
+        const localPath = join2(mediaDir, `${msg.messageId}-${mediaPaths.length}.${ext}`);
+        await writeFile2(localPath, buffer);
+        mediaPaths.push(localPath);
+        mediaTypes.push(att.mimeType);
+      } catch (err) {
+        log?.warn?.(`[${accountId}] Failed to download attachment ${att.filename}: ${err}`);
+      }
+    }
+  }
   if (msg.attachments?.length) {
     for (const att of msg.attachments) {
       if (att.storageUrl && att.mimeType?.startsWith("image/")) continue;
@@ -14243,7 +14335,7 @@ async function routeInboundMessage(opts) {
 [Attached: ${att.filename}${sizeKb ? `, ${sizeKb}` : ""}]`;
     }
   }
-  log?.info?.(`[${accountId}] Quiubo: inbound from ${senderId} in group ${groupId}: ${text?.slice(0, 100)}`);
+  log?.info?.(`[${accountId}] Quiubo: inbound from ${senderId} in group ${groupId}: ${text?.slice(0, 100)}${mediaPaths.length > 0 ? ` [${mediaPaths.length} image(s)]` : ""}`);
   const sendTyping = async () => {
     try {
       await client.sendTypingIndicator(groupId, botIdentityId);
@@ -14274,8 +14366,11 @@ async function routeInboundMessage(opts) {
     Surface: CHANNEL_ID,
     MessageSid: `quiubo-${msg.messageId}`,
     Timestamp: msg.createdAt ? new Date(msg.createdAt).getTime() : Date.now(),
-    ...mediaUrls.length > 0 && {
-      MediaUrls: mediaUrls,
+    ...mediaPaths.length > 0 && {
+      MediaPath: mediaPaths[0],
+      MediaUrl: mediaPaths[0],
+      MediaPaths: mediaPaths,
+      MediaUrls: mediaPaths,
       MediaTypes: mediaTypes
     }
   });
@@ -14297,13 +14392,13 @@ async function routeInboundMessage(opts) {
           const fileUrls = [];
           if (payload.mediaUrl) fileUrls.push(payload.mediaUrl);
           if (Array.isArray(payload.mediaUrls)) fileUrls.push(...payload.mediaUrls);
-          const mdAttachments = await readMdAttachments(fileUrls, agentSource, log, accountId);
+          const outboundAttachments = await readOutboundAttachments(fileUrls, agentSource, client, groupId, log, accountId);
           if (payload.media?.length) {
-            const existingFilenames = new Set(mdAttachments.map((a) => a.filename));
+            const existingFilenames = new Set(outboundAttachments.map((a) => a.filename));
             for (const m of payload.media) {
               const filename = m.filename || m.name || "";
               if (filename.endsWith(".md") && typeof m.content === "string" && !existingFilenames.has(filename)) {
-                mdAttachments.push({
+                outboundAttachments.push({
                   filename,
                   mimeType: "text/markdown",
                   content: m.content,
@@ -14312,8 +14407,8 @@ async function routeInboundMessage(opts) {
               }
             }
           }
-          log?.info?.(`[${accountId}] Quiubo: after dedup: ${mdAttachments.length} attachments [${mdAttachments.map((a) => a.filename).join(", ")}]`);
-          if (!payload.text && mdAttachments.length === 0) {
+          log?.info?.(`[${accountId}] Quiubo: after dedup: ${outboundAttachments.length} attachments [${outboundAttachments.map((a) => a.filename).join(", ")}]`);
+          if (!payload.text && outboundAttachments.length === 0) {
             log?.debug?.(`[${accountId}] Quiubo: skipping empty ${info.kind} reply`);
             return;
           }
@@ -14326,11 +14421,13 @@ async function routeInboundMessage(opts) {
           if (payload.text) {
             payload.text = payload.text.replace(/\n*Reasoning:\n_[^_]*_\n*/g, "").trim();
           }
-          if (!payload.text && mdAttachments.length === 0) {
+          if (!payload.text && outboundAttachments.length === 0) {
             log?.debug?.(`[${accountId}] Quiubo: skipping empty reply after reasoning strip`);
             return;
           }
-          log?.info?.(`[${accountId}] Quiubo: delivering ${info.kind} reply [${payload.text?.length ?? 0} chars, ${mdAttachments.length} attachments]`);
+          const imageAttachments2 = outboundAttachments.filter((a) => a.mimeType.startsWith("image/"));
+          const nonImageAttachments = outboundAttachments.filter((a) => !a.mimeType.startsWith("image/"));
+          log?.info?.(`[${accountId}] Quiubo: delivering ${info.kind} reply [${payload.text?.length ?? 0} chars, ${nonImageAttachments.length} non-image attachments, ${imageAttachments2.length} images]`);
           try {
             let ciphertextOut;
             if (e2eeGrantedGroups?.has(groupId) && keyManager && payload.text) {
@@ -14347,16 +14444,26 @@ async function routeInboundMessage(opts) {
                 log?.warn?.(`[${accountId}] Quiubo: no epoch key for E2EE group ${groupId}, sending plaintext`);
               }
             }
-            const apiResp = await client.sendMessage(groupId, {
-              senderIdentityId: botIdentityId,
-              ...ciphertextOut ? { ciphertext: ciphertextOut } : { plaintext: payload.text || "" },
-              metadata: { format: "markdown" },
-              ...mdAttachments.length > 0 ? { attachments: mdAttachments } : {}
-            });
-            if (apiResp?.realtimeDelivered === false) {
-              log?.warn?.(`[${accountId}] Quiubo: reply persisted but Pusher delivery failed for group ${groupId} \u2014 clients will see on next poll`);
-            } else {
-              log?.info?.(`[${accountId}] Quiubo: reply sent to group ${groupId} (realtime=${apiResp?.realtimeDelivered})`);
+            if (payload.text || nonImageAttachments.length > 0) {
+              const apiResp = await client.sendMessage(groupId, {
+                senderIdentityId: botIdentityId,
+                ...ciphertextOut ? { ciphertext: ciphertextOut } : { plaintext: payload.text || " " },
+                metadata: { format: "markdown" },
+                ...nonImageAttachments.length > 0 ? { attachments: nonImageAttachments } : {}
+              });
+              if (apiResp?.realtimeDelivered === false) {
+                log?.warn?.(`[${accountId}] Quiubo: reply persisted but Pusher delivery failed for group ${groupId} \u2014 clients will see on next poll`);
+              } else {
+                log?.info?.(`[${accountId}] Quiubo: reply sent to group ${groupId} (realtime=${apiResp?.realtimeDelivered})`);
+              }
+            }
+            for (const img of imageAttachments2) {
+              const imgResp = await client.sendMessage(groupId, {
+                senderIdentityId: botIdentityId,
+                plaintext: " ",
+                attachments: [img]
+              });
+              log?.info?.(`[${accountId}] Quiubo: image ${img.filename} sent to group ${groupId} (realtime=${imgResp?.realtimeDelivered})`);
             }
           } catch (error) {
             if (error instanceof QuiuboApiError) {