@sesamespace/sesame 0.2.2 → 0.2.3

package/dist/index.js

@@ -19,6 +19,18 @@ const connections = new Map();
 function getLogger() {
     return (pluginRuntime?.logging?.getChildLogger?.({ plugin: "sesame" }) ?? console);
 }
+function guessContentType(fileName) {
+    const ext = fileName.split(".").pop()?.toLowerCase() ?? "";
+    const map = {
+        jpg: "image/jpeg", jpeg: "image/jpeg", png: "image/png", gif: "image/gif",
+        webp: "image/webp", svg: "image/svg+xml", pdf: "application/pdf",
+        mp3: "audio/mpeg", mp4: "video/mp4", webm: "video/webm",
+        json: "application/json", txt: "text/plain", md: "text/markdown",
+        csv: "text/csv", html: "text/html", xml: "application/xml",
+        zip: "application/zip", tar: "application/x-tar", gz: "application/gzip",
+    };
+    return map[ext] ?? "application/octet-stream";
+}
 const sesameChannelPlugin = {
     id: "sesame",
     meta: {
@@ -31,7 +43,7 @@ const sesameChannelPlugin = {
     },
     capabilities: {
         chatTypes: ["direct", "group"],
-        media: false,
+        media: true,
         reactions: true,
         threads: true,
         editing: true,
@@ -154,9 +166,108 @@ const sesameChannelPlugin = {
             };
         },
         sendMedia: async (ctx) => {
-            // Sesame doesn't support media attachments yet — fall back to text
-            const text = ctx.caption ?? ctx.text ?? "[media attachment]";
-            return sesameChannelPlugin.outbound.sendText({ ...ctx, text });
+            const { text, mediaUrl, cfg, accountId } = ctx;
+            const account = sesameChannelPlugin.config.resolveAccount(cfg, accountId);
+            if (!account?.apiKey)
+                throw new Error("Sesame not configured");
+            const channelId = ctx.to?.startsWith("sesame:") ? ctx.to.slice(7) : ctx.to;
+            const caption = ctx.caption ?? text ?? "";
+            const log = getLogger();
+            try {
+                // Resolve media source: local file path or URL
+                const fs = await import("fs");
+                const path = await import("path");
+                let fileBuffer;
+                let fileName;
+                let contentType;
+                if (mediaUrl && (mediaUrl.startsWith("/") || mediaUrl.startsWith("~"))) {
+                    // Local file path
+                    const resolvedPath = mediaUrl.startsWith("~")
+                        ? mediaUrl.replace("~", process.env.HOME ?? "")
+                        : mediaUrl;
+                    fileBuffer = fs.readFileSync(resolvedPath);
+                    fileName = path.basename(resolvedPath);
+                    contentType = guessContentType(fileName);
+                }
+                else if (mediaUrl) {
+                    // Remote URL — download it
+                    const response = await fetch(mediaUrl);
+                    if (!response.ok)
+                        throw new Error(`Failed to download media: ${response.status}`);
+                    fileBuffer = Buffer.from(await response.arrayBuffer());
+                    // Extract filename from URL or Content-Disposition
+                    const urlPath = new URL(mediaUrl).pathname;
+                    fileName = path.basename(urlPath) || "attachment";
+                    contentType = response.headers.get("content-type") ?? guessContentType(fileName);
+                }
+                else {
+                    // No media URL — fall back to text
+                    return sesameChannelPlugin.outbound.sendText({ ...ctx, text: caption || "[media attachment]" });
+                }
+                // 1. Get presigned upload URL from Sesame Drive
+                const uploadRes = await fetch(`${account.apiUrl}/api/v1/drive/files/upload-url`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${account.apiKey}`,
+                    },
+                    body: JSON.stringify({ fileName, contentType, size: fileBuffer.length }),
+                });
+                if (!uploadRes.ok)
+                    throw new Error(`Drive upload-url failed: ${uploadRes.status}`);
+                const uploadData = (await uploadRes.json());
+                const { uploadUrl, fileId, s3Key } = uploadData.data;
+                // 2. Upload to S3
+                const s3Res = await fetch(uploadUrl, {
+                    method: "PUT",
+                    headers: { "Content-Type": contentType },
+                    body: new Uint8Array(fileBuffer),
+                });
+                if (!s3Res.ok)
+                    throw new Error(`S3 upload failed: ${s3Res.status}`);
+                // 3. Register file in Drive
+                const regRes = await fetch(`${account.apiUrl}/api/v1/drive/files`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${account.apiKey}`,
+                    },
+                    body: JSON.stringify({ fileId, s3Key, fileName, contentType, size: fileBuffer.length }),
+                });
+                if (!regRes.ok)
+                    throw new Error(`Drive register failed: ${regRes.status}`);
+                // 4. Send message with attachment
+                const msgRes = await fetch(`${account.apiUrl}/api/v1/channels/${channelId}/messages`, {
+                    method: "POST",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${account.apiKey}`,
+                    },
+                    body: JSON.stringify({
+                        content: caption || fileName,
+                        kind: "text",
+                        intent: "chat",
+                        attachmentIds: [fileId],
+                    }),
+                });
+                if (!msgRes.ok)
+                    throw new Error(`Send message failed: ${msgRes.status}`);
+                const msgData = (await msgRes.json());
+                log.info?.(`[sesame] Sent file "${fileName}" (${fileBuffer.length} bytes) to ${channelId}`);
+                return {
+                    channel: "sesame",
+                    messageId: msgData.data?.id ?? msgData.id ?? "unknown",
+                    chatId: channelId,
+                };
+            }
+            catch (err) {
+                log.error?.(`[sesame] sendMedia failed: ${err}`);
+                // Fall back to text with caption
+                return sesameChannelPlugin.outbound.sendText({
+                    ...ctx,
+                    text: caption || "[media attachment — upload failed]",
+                });
+            }
         },
     },
     messaging: {
@@ -207,6 +318,9 @@ async function connect(account, ctx) {
         stopping: false,
         ctx,
         channelMap: new Map(),
+        sentMessageIds: new Set(),
+        recentOutboundCount: 0,
+        outboundWindowStart: Date.now(),
     };
     connections.set(account.accountId, state);
     try {
@@ -286,6 +400,10 @@ function handleEvent(event, account, state, ctx) {
     switch (event.type) {
         case "authenticated":
             state.authenticated = true;
+            if (event.principalId && !state.agentId) {
+                state.agentId = event.principalId;
+                log.info?.(`[sesame] Agent ID from auth: ${state.agentId}`);
+            }
             state.heartbeatTimer = setInterval(() => {
                 if (state.ws?.readyState === 1) {
                     state.ws.send(JSON.stringify({ type: "ping" }));
@@ -294,9 +412,45 @@ function handleEvent(event, account, state, ctx) {
             log.info?.("[sesame] Authenticated successfully");
             state.ws?.send(JSON.stringify({ type: "replay", cursors: {} }));
             break;
-        case "message":
-            handleMessage(event.message ?? event.data, account, state, ctx);
+        case "message": {
+            const msg = event.message ?? event.data;
+            // Skip voice messages without transcription — wait for voice.transcribed event
+            if (msg?.kind === "voice") {
+                const meta = msg.metadata ?? {};
+                const transcript = meta.transcript;
+                if (!transcript) {
+                    log.info?.(`[sesame] Voice message ${msg.id} — waiting for transcription`);
+                    break;
+                }
+            }
+            handleMessage(msg, account, state, ctx);
+            break;
+        }
+        case "voice.transcribed": {
+            // Transcription completed — dispatch as a regular message with transcript text
+            const vtData = event;
+            const transcript = vtData.transcript;
+            const messageId = vtData.messageId;
+            const channelId = vtData.channelId;
+            const senderId = vtData.senderId;
+            if (!transcript || !messageId || !channelId) {
+                log.warn?.("[sesame] voice.transcribed event missing fields");
+                break;
+            }
+            log.info?.(`[sesame] Voice transcribed for ${messageId}: "${transcript.slice(0, 80)}"`);
+            // Build a synthetic message object so handleMessage can process it
+            handleMessage({
+                id: messageId,
+                channelId,
+                senderId,
+                kind: "voice",
+                content: transcript,
+                plaintext: transcript,
+                metadata: { transcript },
+                createdAt: new Date().toISOString(),
+            }, account, state, ctx);
             break;
+        }
         case "membership": {
             // Track new channel joins so ChatType resolves correctly
             const mData = event.data ?? event.membership ?? event;
@@ -327,13 +481,27 @@ async function handleMessage(message, account, state, ctx) {
     const core = pluginRuntime;
     if (!core)
         return;
-    const bodyText = message.content ?? message.plaintext ?? message.body ?? message.text ?? "";
+    // For voice messages, prefer transcript from metadata over content
+    const msgMeta = message.metadata ?? {};
+    const voiceTranscript = message.kind === "voice" ? msgMeta.transcript : undefined;
+    const rawText = voiceTranscript ?? message.content ?? message.plaintext ?? message.body ?? message.text ?? "";
+    const bodyText = message.kind === "voice" && rawText ? `(voice note)\n${rawText}` : rawText;
     const channelId = message.channelId;
     const messageId = message.id;
     log.info?.(`[sesame] Message from ${message.senderId} in ${channelId}: "${bodyText.slice(0, 100)}"`);
-    // Skip own messages
+    // Skip own messages (by sender ID)
     if (message.senderId === state.agentId)
         return;
+    // Skip messages we sent (by message ID tracking)
+    if (state.sentMessageIds.has(messageId)) {
+        state.sentMessageIds.delete(messageId);
+        return;
+    }
+    // Don't process messages until we know our own agent ID
+    if (!state.agentId) {
+        log.warn?.(`[sesame] Skipping message — agentId not resolved yet`);
+        return;
+    }
     // Channel filter (empty = all channels)
     if (account.channels.length > 0 && !account.channels.includes(channelId))
         return;
@@ -448,6 +616,16 @@ async function handleMessage(message, account, state, ctx) {
             const fullReply = replyBuffer.join("\n\n").trim();
             if (!fullReply)
                 return;
+            // Outbound circuit breaker: max 5 messages per 10s window
+            const cbNow = Date.now();
+            if (cbNow - state.outboundWindowStart > 10000) {
+                state.recentOutboundCount = 0;
+                state.outboundWindowStart = cbNow;
+            }
+            if (state.recentOutboundCount >= 5) {
+                log.error?.(`[sesame] Circuit breaker: suppressing outbound message (${state.recentOutboundCount} msgs in ${Math.round((cbNow - state.outboundWindowStart) / 1000)}s)`);
+                return;
+            }
             log.info?.(`[sesame] Flushing buffered reply (${fullReply.length} chars): "${fullReply.slice(0, 100)}"`);
             const res = await fetch(`${account.apiUrl}/api/v1/channels/${channelId}/messages`, {
                 method: "POST",
@@ -467,6 +645,23 @@ async function handleMessage(message, account, state, ctx) {
             }
             else {
                 log.info?.(`[sesame] Sent buffered reply to ${channelId} (${res.status})`);
+                // Track sent message ID to detect self-echoes
+                try {
+                    const resData = (await res.clone().json().catch(() => ({})));
+                    const sentId = resData.data?.id ?? resData.id;
+                    if (sentId) {
+                        state.sentMessageIds.add(sentId);
+                        // Cap set size at 1000
+                        if (state.sentMessageIds.size > 1000) {
+                            const first = state.sentMessageIds.values().next().value;
+                            if (first)
+                                state.sentMessageIds.delete(first);
+                        }
+                    }
+                }
+                catch { }
+                // Track outbound count for circuit breaker
+                state.recentOutboundCount++;
             }
         };
         const { dispatcher, replyOptions, markDispatchIdle } = core.channel.reply.createReplyDispatcherWithTyping({

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "sesame",
   "name": "Sesame",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Connect your OpenClaw agent to Sesame — the agent-native messaging platform",
   "channels": ["sesame"],
   "channel": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sesamespace/sesame",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "description": "Sesame channel plugin for OpenClaw — connect your AI agent to the Sesame messaging platform",
   "type": "module",
   "main": "dist/index.js",
@@ -56,6 +56,7 @@
     "ws": "^8.18.0"
   },
   "devDependencies": {
+    "@types/node": "^25.3.3",
     "typescript": "^5.9.3"
   }
 }