@clawchatsai/connector 0.0.30 → 0.0.31

package/dist/index.js

@@ -488,15 +488,33 @@ async function handleRpcMessage(dc, msg, ctx) {
     };
     try {
         const response = await dispatchRpc(rpcReq, app.handleRequest);
+        // For binary content types (images, audio, etc.), wrap as _binary envelope
+        // so the browser transport can reconstruct a proper Blob with correct MIME type
+        const contentType = response.headers['content-type'] || '';
+        const isBinaryResponse = /^(image|audio|video|application\/octet-stream|application\/pdf)/.test(contentType);
+        let responseBody;
+        if (isBinaryResponse && response.rawBody) {
+            // Encode raw bytes as base64 in a _binary envelope.
+            // The transport layer on the browser side already handles this format,
+            // reconstructing a proper Blob with the correct MIME type.
+            responseBody = {
+                _binary: true,
+                contentType,
+                data: response.rawBody.toString('base64'),
+            };
+        }
+        else {
+            responseBody = response.body;
+        }
         const responseMsg = {
             type: 'rpc-res',
             id: response.id,
             status: response.status,
-            body: response.body,
+            body: responseBody,
         };
         const responseStr = JSON.stringify(responseMsg);
         if (responseStr.length > MAX_DC_MESSAGE_SIZE) {
-            sendChunked(dc, response.id, response.status, response.body);
+            sendChunked(dc, response.id, response.status, JSON.stringify(responseBody));
         }
         else {
             dc.send(responseStr);

package/dist/shim.d.ts

@@ -20,6 +20,7 @@ export interface RpcResponse {
     status: number;
     headers: Record<string, string>;
     body: string;
+    rawBody?: Buffer;
 }
 type HandleRequestFn = (req: FakeReq, res: FakeRes) => void | Promise<void>;
 /**

package/dist/shim.js

@@ -150,5 +150,6 @@ export async function dispatchRpc(rpc, handleRequest) {
         status: result.status,
         headers: result.headers,
         body: tryJsonParse(result.body),
+        rawBody: result.body, // Preserve raw buffer for binary encoding
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@clawchatsai/connector",
-  "version": "0.0.30",
+  "version": "0.0.31",
   "type": "module",
   "description": "ClawChats OpenClaw plugin — P2P tunnel + local API bridge",
   "main": "dist/index.js",

package/server.js

@@ -2037,16 +2037,17 @@ async function handleRequest(req, res) {
     const isIcon = urlPath.startsWith('/icons/');
     const isLib = urlPath.startsWith('/lib/');
     const isFrontend = urlPath.startsWith('/frontend/');
+    const isEmoji = urlPath.startsWith('/emoji/');
     const isConfig = urlPath === '/config.js';
     const staticPath = fileName ? path.join(__dirname, fileName)
-      : (isIcon || isLib || isFrontend || isConfig) ? path.join(__dirname, urlPath.slice(1))
+      : (isIcon || isLib || isFrontend || isEmoji || isConfig) ? path.join(__dirname, urlPath.slice(1))
       : null;
     if (staticPath && fs.existsSync(staticPath) && fs.statSync(staticPath).isFile()) {
       const ext = path.extname(staticPath).toLowerCase();
       const mimeMap = {
         '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css',
         '.json': 'application/json', '.ico': 'image/x-icon',
-        '.png': 'image/png', '.svg': 'image/svg+xml',
+        '.png': 'image/png', '.svg': 'image/svg+xml', '.gif': 'image/gif', '.webp': 'image/webp',
       };
       const ct = mimeMap[ext] || 'application/octet-stream';
       const stat = fs.statSync(staticPath);
@@ -2065,6 +2066,133 @@ async function handleRequest(req, res) {
     return handleServeUpload(req, res, p);
   }
 
+  // Custom emoji listing (no auth — public like static assets)
+  if (method === 'GET' && urlPath === '/api/emoji') {
+    const emojiDir = path.join(__dirname, 'emoji');
+    if (!fs.existsSync(emojiDir)) {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      return res.end('[]');
+    }
+    try {
+      const packs = fs.readdirSync(emojiDir).filter(d =>
+        fs.statSync(path.join(emojiDir, d)).isDirectory()
+      );
+      const result = [];
+      for (const pack of packs) {
+        const packDir = path.join(emojiDir, pack);
+        const files = fs.readdirSync(packDir).filter(f =>
+          /\.(png|gif|webp|jpg|jpeg)$/i.test(f)
+        );
+        for (const file of files) {
+          const name = file.replace(/\.[^.]+$/, '');
+          result.push({ name, pack, path: `/emoji/${pack}/${file}` });
+        }
+      }
+      res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'public, max-age=300' });
+      return res.end(JSON.stringify(result));
+    } catch (e) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      return res.end(JSON.stringify({ error: e.message }));
+    }
+  }
+
+  // Search slackmojis.com (scrapes HTML search since JSON API has no search)
+  if (method === 'GET' && urlPath === '/api/emoji/search') {
+    const q = query.q || '';
+    if (!q) {
+      res.writeHead(400, { 'Content-Type': 'application/json' });
+      return res.end(JSON.stringify({ error: 'Missing ?q= parameter' }));
+    }
+    try {
+      const https = await import('https');
+      const fetchUrl = `https://slackmojis.com/emojis/search?query=${encodeURIComponent(q)}`;
+      const html = await new Promise((resolve, reject) => {
+        https.default.get(fetchUrl, (resp) => {
+          let body = '';
+          resp.on('data', chunk => body += chunk);
+          resp.on('end', () => resolve(body));
+        }).on('error', reject);
+      });
+      // Parse emoji entries from HTML:
+      // <li class='emoji name' title='name'>
+      // <a ... data-emoji-id="123" data-emoji-id-name="123-name" href="/emojis/123-name/download">
+      // <img ... src="https://emojis.slackmojis.com/emojis/images/.../name.png?..." />
+      const results = [];
+      const regex = /data-emoji-id-name="([^"]+)"[^>]*href="([^"]+)"[\s\S]*?<img[^>]*src="([^"]+)"/g;
+      let match;
+      while ((match = regex.exec(html)) !== null && results.length < 50) {
+        const idName = match[1]; // e.g. "57350-sextant"
+        const downloadPath = match[2];
+        const imageUrl = match[3];
+        const name = idName.replace(/^\d+-/, '');
+        results.push({
+          name,
+          image_url: imageUrl,
+          download_url: `https://slackmojis.com${downloadPath}`,
+        });
+      }
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      return res.end(JSON.stringify(results));
+    } catch (e) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      return res.end(JSON.stringify({ error: e.message }));
+    }
+  }
+
+  // Download emoji from URL and save to emoji/ directory
+  if (method === 'POST' && urlPath === '/api/emoji/add') {
+    if (!checkAuth(req, res)) return;
+    try {
+      const { url, name, pack } = await parseBody(req);
+      if (!url || !name) {
+        res.writeHead(400, { 'Content-Type': 'application/json' });
+        return res.end(JSON.stringify({ error: 'Missing url or name' }));
+      }
+      const targetPack = pack || 'custom';
+      const emojiDir = path.join(__dirname, 'emoji', targetPack);
+      if (!fs.existsSync(emojiDir)) fs.mkdirSync(emojiDir, { recursive: true });
+
+      // Follow redirects and download
+      const https = await import('https');
+      const http = await import('http');
+      const download = (downloadUrl, redirects = 0) => new Promise((resolve, reject) => {
+        if (redirects > 5) return reject(new Error('Too many redirects'));
+        const mod = downloadUrl.startsWith('https') ? https.default : http.default;
+        mod.get(downloadUrl, (resp) => {
+          if (resp.statusCode >= 300 && resp.statusCode < 400 && resp.headers.location) {
+            return resolve(download(resp.headers.location, redirects + 1));
+          }
+          if (resp.statusCode !== 200) return reject(new Error(`HTTP ${resp.statusCode}`));
+          const chunks = [];
+          resp.on('data', chunk => chunks.push(chunk));
+          resp.on('end', () => resolve({ buffer: Buffer.concat(chunks), contentType: resp.headers['content-type'] || '' }));
+        }).on('error', reject);
+      });
+
+      const { buffer, contentType } = await download(url);
+      // Determine extension from content-type or URL
+      let ext = 'png';
+      if (contentType.includes('gif')) ext = 'gif';
+      else if (contentType.includes('webp')) ext = 'webp';
+      else if (contentType.includes('jpeg') || contentType.includes('jpg')) ext = 'jpg';
+      else {
+        const urlExt = url.split('?')[0].split('.').pop().toLowerCase();
+        if (['png', 'gif', 'webp', 'jpg', 'jpeg'].includes(urlExt)) ext = urlExt;
+      }
+
+      const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '_');
+      const filePath = path.join(emojiDir, `${safeName}.${ext}`);
+      fs.writeFileSync(filePath, buffer);
+
+      const result = { name: safeName, pack: targetPack, path: `/emoji/${targetPack}/${safeName}.${ext}` };
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      return res.end(JSON.stringify(result));
+    } catch (e) {
+      res.writeHead(500, { 'Content-Type': 'application/json' });
+      return res.end(JSON.stringify({ error: e.message }));
+    }
+  }
+
   // Auth check for all other routes
   if (!checkAuth(req, res)) return;
 
@@ -3247,10 +3375,14 @@ export function createApp(config = {}) {
       return sendError(res, 400, 'Required: id, role, content, timestamp');
     }
     const metadata = body.metadata ? JSON.stringify(body.metadata) : null;
-    const existing = db.prepare('SELECT id, status FROM messages WHERE id = ?').get(body.id);
+    const existing = db.prepare('SELECT id, status, metadata FROM messages WHERE id = ?').get(body.id);
     if (existing) {
-      if (body.status && body.status !== existing.status) {
-        db.prepare('UPDATE messages SET status = ?, content = ?, metadata = ? WHERE id = ?').run(body.status, body.content, metadata, body.id);
+      const newStatus = body.status || existing.status;
+      const statusChanged = body.status && body.status !== existing.status;
+      if (statusChanged || metadata) {
+        // Only overwrite metadata if new metadata is provided; otherwise preserve existing
+        const finalMetadata = metadata || existing.metadata || null;
+        db.prepare('UPDATE messages SET status = ?, content = ?, metadata = ? WHERE id = ?').run(newStatus, body.content, finalMetadata, body.id);
       }
     } else {
       db.prepare('INSERT INTO messages (id, thread_id, role, content, status, metadata, seq, timestamp, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)').run(body.id, params.id, body.role, body.content, body.status || 'sent', metadata, body.seq || null, body.timestamp, Date.now());
@@ -3869,11 +4001,12 @@ export function createApp(config = {}) {
       const isIcon = urlPath.startsWith('/icons/');
       const isLib = urlPath.startsWith('/lib/');
       const isFrontend = urlPath.startsWith('/frontend/');
+      const isEmoji = urlPath.startsWith('/emoji/');
       const isConfig = urlPath === '/config.js';
-      const staticPath = fileName ? path.join(__dirname, fileName) : (isIcon || isLib || isFrontend || isConfig) ? path.join(__dirname, urlPath.slice(1)) : null;
+      const staticPath = fileName ? path.join(__dirname, fileName) : (isIcon || isLib || isFrontend || isEmoji || isConfig) ? path.join(__dirname, urlPath.slice(1)) : null;
       if (staticPath && fs.existsSync(staticPath) && fs.statSync(staticPath).isFile()) {
         const ext = path.extname(staticPath).toLowerCase();
-        const mimeMap = { '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css', '.json': 'application/json', '.ico': 'image/x-icon', '.png': 'image/png', '.svg': 'image/svg+xml' };
+        const mimeMap = { '.html': 'text/html', '.js': 'text/javascript', '.css': 'text/css', '.json': 'application/json', '.ico': 'image/x-icon', '.png': 'image/png', '.svg': 'image/svg+xml', '.gif': 'image/gif', '.webp': 'image/webp' };
         const ct = mimeMap[ext] || 'application/octet-stream';
         const stat = fs.statSync(staticPath);
         res.writeHead(200, { 'Content-Type': ct, 'Content-Length': stat.size, 'Cache-Control': ext === '.html' ? 'no-cache' : 'public, max-age=3600' });
@@ -3884,8 +4017,79 @@ export function createApp(config = {}) {
     let p;
     if ((p = matchRoute(method, urlPath, 'GET /api/uploads/:threadId/:fileId'))) return _handleServeUpload(req, res, p);
 
+    // Custom emoji listing (no auth)
+    if (method === 'GET' && urlPath === '/api/emoji') {
+      const emojiDir = path.join(__dirname, 'emoji');
+      if (!fs.existsSync(emojiDir)) { res.writeHead(200, { 'Content-Type': 'application/json' }); return res.end('[]'); }
+      try {
+        const packs = fs.readdirSync(emojiDir).filter(d => fs.statSync(path.join(emojiDir, d)).isDirectory());
+        const result = [];
+        for (const pack of packs) {
+          const files = fs.readdirSync(path.join(emojiDir, pack)).filter(f => /\.(png|gif|webp|jpg|jpeg)$/i.test(f));
+          for (const file of files) result.push({ name: file.replace(/\.[^.]+$/, ''), pack, path: `/emoji/${pack}/${file}` });
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json', 'Cache-Control': 'public, max-age=300' });
+        return res.end(JSON.stringify(result));
+      } catch (e) { res.writeHead(500, { 'Content-Type': 'application/json' }); return res.end(JSON.stringify({ error: e.message })); }
+    }
+
+    // Search slackmojis.com (no auth, proxied)
+    if (method === 'GET' && urlPath === '/api/emoji/search') {
+      const q = query.q || '';
+      if (!q) { res.writeHead(400, { 'Content-Type': 'application/json' }); return res.end(JSON.stringify({ error: 'Missing ?q=' })); }
+      try {
+        const https = await import('https');
+        const html = await new Promise((resolve, reject) => {
+          https.default.get(`https://slackmojis.com/emojis/search?query=${encodeURIComponent(q)}`, (resp) => {
+            let body = ''; resp.on('data', c => body += c); resp.on('end', () => resolve(body));
+          }).on('error', reject);
+        });
+        const results = [];
+        const regex = /data-emoji-id-name="([^"]+)"[^>]*href="([^"]+)"[\s\S]*?<img[^>]*src="([^"]+)"/g;
+        let match;
+        while ((match = regex.exec(html)) !== null && results.length < 50) {
+          const name = match[1].replace(/^\d+-/, '');
+          results.push({ name, image_url: match[3], download_url: `https://slackmojis.com${match[2]}` });
+        }
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        return res.end(JSON.stringify(results));
+      } catch (e) { res.writeHead(500, { 'Content-Type': 'application/json' }); return res.end(JSON.stringify({ error: e.message })); }
+    }
+
     if (!_checkAuth(req, res)) return;
 
+    // Download emoji from URL (auth required)
+    if (method === 'POST' && urlPath === '/api/emoji/add') {
+      try {
+        const { url, name, pack } = await parseBody(req);
+        if (!url || !name) { res.writeHead(400, { 'Content-Type': 'application/json' }); return res.end(JSON.stringify({ error: 'Missing url or name' })); }
+        const targetPack = pack || 'custom';
+        const emojiDir = path.join(__dirname, 'emoji', targetPack);
+        if (!fs.existsSync(emojiDir)) fs.mkdirSync(emojiDir, { recursive: true });
+        const https = await import('https');
+        const http = await import('http');
+        const download = (dlUrl, redirects = 0) => new Promise((resolve, reject) => {
+          if (redirects > 5) return reject(new Error('Too many redirects'));
+          const mod = dlUrl.startsWith('https') ? https.default : http.default;
+          mod.get(dlUrl, (resp) => {
+            if (resp.statusCode >= 300 && resp.statusCode < 400 && resp.headers.location) return resolve(download(resp.headers.location, redirects + 1));
+            if (resp.statusCode !== 200) return reject(new Error(`HTTP ${resp.statusCode}`));
+            const chunks = []; resp.on('data', c => chunks.push(c)); resp.on('end', () => resolve({ buffer: Buffer.concat(chunks), contentType: resp.headers['content-type'] || '' }));
+          }).on('error', reject);
+        });
+        const { buffer, contentType } = await download(url);
+        let ext = 'png';
+        if (contentType.includes('gif')) ext = 'gif';
+        else if (contentType.includes('webp')) ext = 'webp';
+        else if (contentType.includes('jpeg') || contentType.includes('jpg')) ext = 'jpg';
+        else { const u = url.split('?')[0].split('.').pop().toLowerCase(); if (['png','gif','webp','jpg','jpeg'].includes(u)) ext = u; }
+        const safeName = name.replace(/[^a-zA-Z0-9_-]/g, '_');
+        fs.writeFileSync(path.join(emojiDir, `${safeName}.${ext}`), buffer);
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        return res.end(JSON.stringify({ name: safeName, pack: targetPack, path: `/emoji/${targetPack}/${safeName}.${ext}` }));
+      } catch (e) { res.writeHead(500, { 'Content-Type': 'application/json' }); return res.end(JSON.stringify({ error: e.message })); }
+    }
+
     try {
       if (method === 'GET' && urlPath === '/api/file') return handleServeFile(req, res, query);
       if (method === 'GET' && urlPath === '/api/workspace') return handleWorkspaceList(req, res, query);