osborn 0.8.14 → 0.8.15

package/dist/index.js

@@ -818,7 +818,13 @@ async function main() {
         proactivePromptHistory = [];
     }
     // Helper to send data to frontend (with size limit handling)
-    const MAX_MESSAGE_SIZE = 60000;
+    //
+    // WebRTC SCTP data channel max message size is ~256KB. Sending larger
+    // payloads corrupts the publisher transport, killing ALL subsequent sends.
+    // We enforce a soft limit (truncate text/content fields) and a hard limit
+    // (drop the message entirely with a warning) to prevent this.
+    const MAX_MESSAGE_SIZE = 60000; // soft limit — truncate text/content fields
+    const HARD_MAX_MESSAGE_SIZE = 200000; // hard limit — drop if still too large after truncation
     async function sendToFrontend(data) {
         if (!localParticipant) {
             console.log('⚠️ sendToFrontend: no localParticipant!');
@@ -827,18 +833,36 @@ async function main() {
         try {
             const encoder = new TextEncoder();
             let jsonData = JSON.stringify(data);
-            // If message is too large, truncate the text content
+            // If message is too large, truncate the text or content field
             if (jsonData.length > MAX_MESSAGE_SIZE) {
                 const truncatedData = { ...data };
+                // Try truncating .text first (assistant_response, claude_output, etc.)
                 if (truncatedData.text && typeof truncatedData.text === 'string') {
                     const overhead = JSON.stringify({ ...truncatedData, text: '' }).length;
                     const maxTextLength = MAX_MESSAGE_SIZE - overhead - 100;
                     truncatedData.text = truncatedData.text.substring(0, maxTextLength) + '\n\n[Message truncated due to size limit]';
                     jsonData = JSON.stringify(truncatedData);
-                    console.log(`⚠️ Message truncated from ${data.text?.length} to ${truncatedData.text.length} chars`);
+                    console.log(`⚠️ Message truncated .text from ${data.text?.length} to ${truncatedData.text.length} chars`);
+                }
+                // Also try truncating .content (research_artifact_content, plan_file_content)
+                if (jsonData.length > MAX_MESSAGE_SIZE && truncatedData.content && typeof truncatedData.content === 'string') {
+                    const overhead = JSON.stringify({ ...truncatedData, content: '' }).length;
+                    const maxContentLength = MAX_MESSAGE_SIZE - overhead - 100;
+                    truncatedData.content = truncatedData.content.substring(0, maxContentLength) + '\n\n[Content truncated due to size limit]';
+                    truncatedData.truncated = true;
+                    truncatedData.originalSize = Buffer.byteLength(data.content, 'utf-8');
+                    jsonData = JSON.stringify(truncatedData);
+                    console.log(`⚠️ Message truncated .content from ${data.content?.length} to ${truncatedData.content.length} chars`);
                 }
             }
+            // Hard cap — if still too large after truncation, drop entirely.
+            // This prevents a 480KB base64 image or similar from killing the
+            // WebRTC publisher transport (which is unrecoverable without reconnect).
             const payload = encoder.encode(jsonData);
+            if (payload.length > HARD_MAX_MESSAGE_SIZE) {
+                console.error(`❌ sendToFrontend: dropping message (${(payload.length / 1024).toFixed(0)}KB > ${(HARD_MAX_MESSAGE_SIZE / 1024).toFixed(0)}KB hard limit) — type: ${data.type}`);
+                return;
+            }
             await localParticipant.publishData(payload, {
                 reliable: true,
                 topic: 'osborn-updates',
@@ -2677,13 +2701,36 @@ async function main() {
                         const fileName = filePath.split('/').pop() || '';
                         const ext = fileName.split('.').pop()?.toLowerCase() || '';
                         const isImage = ['png', 'jpg', 'jpeg', 'gif', 'webp'].includes(ext);
+                        // WebRTC SCTP data channel max message size is ~256KB. Sending
+                        // larger payloads corrupts the publisher transport, killing ALL
+                        // subsequent sends (publishData, streamBytes, publishTranscription)
+                        // with "could not establish publisher connection: timeout". This
+                        // was the root cause of the career-ops session bug: a 480KB
+                        // evaluation report blew through the limit on resume.
+                        const MAX_DATA_CHANNEL_BYTES = 200_000; // 200KB — safe margin under 256KB SCTP limit
                         if (isImage) {
-                            const base64 = fs.readFileSync(filePath, 'base64');
-                            await sendToFrontend({ type: 'research_artifact_content', filePath, content: base64, fileName, isImage: true, mimeType: `image/${ext}` });
+                            const stats = fs.statSync(filePath);
+                            const base64Size = Math.ceil(stats.size * 4 / 3); // base64 inflates ~33%
+                            if (base64Size > MAX_DATA_CHANNEL_BYTES) {
+                                console.log(`⚠️ Artifact too large for data channel: ${fileName} (${(base64Size / 1024).toFixed(0)}KB base64) — sending truncation notice`);
+                                await sendToFrontend({ type: 'research_artifact_content', filePath, content: '', fileName, isImage: false, truncated: true, originalSize: stats.size });
+                            }
+                            else {
+                                const base64 = fs.readFileSync(filePath, 'base64');
+                                await sendToFrontend({ type: 'research_artifact_content', filePath, content: base64, fileName, isImage: true, mimeType: `image/${ext}` });
+                            }
                         }
                         else {
                             const content = fs.readFileSync(filePath, 'utf-8');
-                            await sendToFrontend({ type: 'research_artifact_content', filePath, content, fileName, isImage: false });
+                            if (Buffer.byteLength(content, 'utf-8') > MAX_DATA_CHANNEL_BYTES) {
+                                // Send a truncated preview + metadata so the frontend knows the file exists
+                                const truncated = content.substring(0, 50_000); // ~50KB text preview
+                                console.log(`⚠️ Artifact too large for data channel: ${fileName} (${(Buffer.byteLength(content, 'utf-8') / 1024).toFixed(0)}KB) — sending truncated preview`);
+                                await sendToFrontend({ type: 'research_artifact_content', filePath, content: truncated, fileName, isImage: false, truncated: true, originalSize: Buffer.byteLength(content, 'utf-8') });
+                            }
+                            else {
+                                await sendToFrontend({ type: 'research_artifact_content', filePath, content, fileName, isImage: false });
+                            }
                         }
                     }
                     catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "osborn",
-  "version": "0.8.14",
+  "version": "0.8.15",
   "description": "Voice AI coding assistant - local agent that connects to Osborn frontend",
   "type": "module",
   "bin": {