@yeaft/webchat-agent 0.1.820 → 0.1.822

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yeaft/webchat-agent",
-  "version": "0.1.820",
+  "version": "0.1.822",
   "description": "Remote agent for Yeaft WebChat — connects worker machines to the central server",
   "main": "index.js",
   "type": "module",

package/unify/attachments.js

@@ -40,8 +40,8 @@
  *     than swallowing it in a console.warn.
  */
 
-import { existsSync, mkdirSync, writeFileSync } from 'node:fs';
-import { basename, extname, join } from 'node:path';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, statSync } from 'node:fs';
+import { basename, extname, join, resolve, relative, isAbsolute } from 'node:path';
 import { randomBytes } from 'node:crypto';
 
 // Same dir name Chat mode uses, so ".gitignore" rules and tool-side
@@ -54,6 +54,7 @@ const TEMP_UPLOAD_DIR = '.claude-tmp-attachments';
 //   - MAX_TOTAL_BYTES:    50 MiB across all files in one turn.
 export const MAX_FILES_PER_TURN = 16;
 export const MAX_TOTAL_BYTES = 50 * 1024 * 1024;
+export const MAX_PREVIEW_BYTES = 10 * 1024 * 1024;
 
 /**
  * Sanitize a user-supplied filename's basename for use as an on-disk
@@ -228,3 +229,49 @@ export function attachmentsForPersistence(promptAttachments) {
     isImage: !!f.isImage,
   }));
 }
+
+/**
+ * Resolve a persisted Unify attachment path to an on-disk file. The persisted
+ * path is intentionally relative (for tool use), so preview hydration must
+ * keep it inside the upload root instead of serving arbitrary files.
+ *
+ * @param {string} attachmentPath
+ * @param {{ cwd?: string }} [opts]
+ * @returns {string|null}
+ */
+export function resolvePersistedAttachmentPath(attachmentPath, opts = {}) {
+  if (!attachmentPath || typeof attachmentPath !== 'string') return null;
+  if (isAbsolute(attachmentPath)) return null;
+  const cwd = resolve(opts.cwd || process.cwd());
+  const uploadRoot = resolve(cwd, TEMP_UPLOAD_DIR);
+  const absPath = resolve(cwd, attachmentPath);
+  const rel = relative(uploadRoot, absPath);
+  if (rel === '' || rel.startsWith('..') || isAbsolute(rel)) return null;
+  return absPath;
+}
+
+/**
+ * Read a persisted image attachment into a short-lived preview payload for the
+ * web server. Returns null for non-images, bad paths, missing files, or files
+ * too large to cache as previews.
+ *
+ * @param {{name?:string, path?:string, mimeType?:string, isImage?:boolean}} att
+ * @param {{ cwd?: string }} [opts]
+ * @returns {{data:string,mimeType:string,filename:string}|null}
+ */
+export function persistedAttachmentPreviewPayload(att, opts = {}) {
+  if (!att || !att.isImage || !att.path) return null;
+  const absPath = resolvePersistedAttachmentPath(att.path, opts);
+  if (!absPath) return null;
+  try {
+    const st = statSync(absPath);
+    if (!st.isFile() || st.size > MAX_PREVIEW_BYTES) return null;
+    return {
+      data: readFileSync(absPath).toString('base64'),
+      mimeType: att.mimeType || 'application/octet-stream',
+      filename: att.name || basename(absPath),
+    };
+  } catch {
+    return null;
+  }
+}

package/unify/conversation/persist.js

@@ -107,6 +107,12 @@ function serializeMessage(msg) {
   // the speaker so the UI can render the message on the correct VP track.
   // For real user messages this is unset.
   if (msg.speakerVpId) fm.push(`speakerVpId: ${msg.speakerVpId}`);
+  if (Array.isArray(msg.attachments) && msg.attachments.length > 0) {
+    try {
+      const b64 = Buffer.from(JSON.stringify(msg.attachments)).toString('base64');
+      fm.push(`attachmentsB64: ${b64}`);
+    } catch { /* best-effort: attachments are UI metadata, not engine-critical */ }
+  }
   // Internal/synthetic rows must round-trip so refresh/history replay can
   // keep them out of the user-visible conversation. Reflection folding uses
   // `_reflection`; other engine-only rows may use one of the explicit flags.
@@ -213,6 +219,12 @@ export function parseMessage(raw) {
       case 'sourceThreadId': msg.sourceThreadId = value; break;
       case 'groupId': msg.groupId = value; break;
       case 'speakerVpId': msg.speakerVpId = value; break;
+      case 'attachmentsB64':
+        try {
+          const parsed = JSON.parse(Buffer.from(value, 'base64').toString('utf8'));
+          if (Array.isArray(parsed)) msg.attachments = parsed;
+        } catch { /* best-effort: ignore malformed attachment metadata */ }
+        break;
       case '_reflection': msg._reflection = value === 'true'; break;
       case 'internal': msg.internal = value === 'true'; break;
       case 'systemOnly': msg.systemOnly = value === 'true'; break;

package/unify/debug-trace.js

@@ -364,11 +364,14 @@ export class DebugTrace {
    * fields the panel expects. JSON columns are parsed; truncated /
    * malformed payloads degrade to null instead of failing the call.
    *
-   * @param {{ limit?: number, groupId?: string|null, threadId?: string|null }} [opts]
-   * @returns {{ loops: object[], turns: object[] }}
+   * @param {{ limit?: number, dreamLimit?: number, groupId?: string|null, threadId?: string|null }} [opts]
+   * @returns {{ loops: object[], turns: object[], dreamEvents: object[] }}
    */
-  fetchRecentDebugHistory({ limit = 100, groupId = null, threadId = null } = {}) {
+  fetchRecentDebugHistory({ limit = 100, dreamLimit = 5, groupId = null, threadId = null } = {}) {
     const lim = Math.max(1, Math.min(500, Number(limit) || 100));
+    const dreamLim = Number.isFinite(Number(dreamLimit))
+      ? Math.max(0, Math.min(50, Number(dreamLimit)))
+      : 5;
     const where = [];
     const args = [];
     if (groupId) { where.push('group_id = ?'); args.push(groupId); }
@@ -471,10 +474,30 @@ export class DebugTrace {
         isError: !!tool.is_error,
       });
     }
+    const dreamEvents = [];
+    if (dreamLim > 0) {
+      const eventRows = this.#db.prepare(`
+        SELECT * FROM trace_events WHERE event_type = 'dream_progress' ORDER BY created_at DESC LIMIT ?
+      `).all(Math.max(dreamLim * 5, dreamLim));
+      for (const er of eventRows) {
+        const data = parseJsonSafe(er.event_data) || {};
+        const evtGroupId = typeof data.groupId === 'string' && data.groupId ? data.groupId : null;
+        const target = typeof data.target === 'string' ? data.target : '';
+        if (groupId) {
+          const isBroadcast = !evtGroupId && !target;
+          const isThisGroup = evtGroupId === groupId || target === `group/${groupId}`;
+          if (!isBroadcast && !isThisGroup) continue;
+        }
+        dreamEvents.push({ type: 'dream_progress', ...data, at: er.created_at, ts: data.ts || er.created_at });
+        if (dreamEvents.length >= dreamLim) break;
+      }
+      dreamEvents.reverse();
+    }
+
     // Reverse to oldest-first so the panel's existing append-driven UI
     // renders in chronological order on hydration.
     loops.reverse();
-    return { loops, turns: Array.from(turnsById.values()) };
+    return { loops, turns: Array.from(turnsById.values()), dreamEvents };
   }
 
   /**
@@ -624,7 +647,7 @@ export class NullTrace {
   cleanup() { return { deletedTurns: 0, deletedTools: 0, deletedEvents: 0 }; }
   purge() {}
   close() {}
-  fetchRecentDebugHistory() { return { loops: [], turns: [] }; }
+  fetchRecentDebugHistory() { return { loops: [], turns: [], dreamEvents: [] }; }
 }
 
 /**

package/unify/web-bridge.js

@@ -52,7 +52,7 @@ import { seedDefaultGroup } from './groups/seed-default.js';
 import {
   trimSnapshotForBudget,
 } from './history-compact.js';
-import { persistUnifyAttachments, attachmentsForPersistence } from './attachments.js';
+import { persistUnifyAttachments, attachmentsForPersistence, persistedAttachmentPreviewPayload } from './attachments.js';
 import { parseSeqFromId } from './conversation/persist.js';
 import { sliceLastNTurns } from './turn-utils.js';
 import { createVpStatusBroker } from './vp-status-broker.js';
@@ -497,6 +497,56 @@ function makeGroupContextStub() {
   };
 }
 
+/**
+ * Parse persisted content that may have been stringified from provider content
+ * blocks, then return only user-visible text. Image/file binary blocks are UI
+ * metadata and must never be rendered as bubble text; attachment chips ride in
+ * `attachments` instead.
+ *
+ * @param {unknown} content
+ * @returns {string}
+ */
+export function __testNormalizePersistedVisibleContent(content) {
+  let value = content;
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('[') && trimmed.endsWith(']')) || (trimmed.startsWith('{') && trimmed.endsWith('}'))) {
+      try { value = JSON.parse(trimmed); } catch { value = content; }
+    }
+  }
+
+  if (Array.isArray(value)) {
+    return value
+      .map((part) => {
+        if (typeof part === 'string') return part;
+        if (!part || typeof part !== 'object') return '';
+        if (part.type === 'text' && typeof part.text === 'string') return part.text;
+        if (part.type === 'input_text' && typeof part.text === 'string') return part.text;
+        return '';
+      })
+      .join('')
+      .replace(/\n\n\[Uploaded files\][\s\S]*$/m, '')
+      .trim();
+  }
+
+  if (value && typeof value === 'object') {
+    if (typeof value.text === 'string') return value.text.trim();
+    if (typeof value.content === 'string') return value.content.trim();
+    return '';
+  }
+
+  return typeof value === 'string'
+    ? value.replace(/\n\n\[Uploaded files\][\s\S]*$/m, '').trim()
+    : '';
+}
+
+function isPersistedInternalMessage(m) {
+  if (!m) return true;
+  if (m._reflection || m.internal || m.systemOnly || m.systemOnlyMessage) return true;
+  if (m.kind === 'compact_summary' || m._compactSummary) return true;
+  return false;
+}
+
 /**
  * Project a persisted message record into the in-memory history shape.
  * Accepts `role:'tool'` and preserves `toolCalls`/`toolCallId` so the
@@ -509,8 +559,8 @@ function makeGroupContextStub() {
 function projectPersistedToHistoryEntry(m) {
   if (!m) return null;
   if (m.role !== 'user' && m.role !== 'assistant' && m.role !== 'tool') return null;
-  if (m._reflection || m.internal || m.systemOnly || m.systemOnlyMessage) return null;
-  const entry = { role: m.role, content: m.content };
+  if (isPersistedInternalMessage(m)) return null;
+  const entry = { role: m.role, content: m.role === 'tool' ? m.content : __testNormalizePersistedVisibleContent(m.content) };
   if (m.id) entry.id = m.id;
   if (m.groupId) entry.groupId = m.groupId;
   if (m.speakerVpId) entry.speakerVpId = m.speakerVpId;
@@ -523,6 +573,9 @@ function projectPersistedToHistoryEntry(m) {
     }));
   }
   if (m.isError) entry.isError = true;
+  if (m.ts) entry.ts = m.ts;
+  if (Array.isArray(m.attachments) && m.attachments.length > 0) entry.attachments = m.attachments;
+  if ((entry.role === 'user' || entry.role === 'assistant') && !entry.content && !entry.attachments) return null;
   return entry;
 }
 
@@ -531,6 +584,16 @@ function projectPersistedToVisibleHistoryEntry(m) {
   return entry && (entry.role === 'user' || entry.role === 'assistant') ? entry : null;
 }
 
+function hydrateHistoryAttachmentPreviews(attachments) {
+  if (!Array.isArray(attachments) || attachments.length === 0) return [];
+  return attachments.map((att) => {
+    if (!att || typeof att !== 'object') return att;
+    if (!att.isImage || att.preview || att.previewData) return att;
+    const payload = persistedAttachmentPreviewPayload(att);
+    return payload ? { ...att, previewData: payload } : att;
+  });
+}
+
 function loadVisibleGroupHistoryPage(store, groupId, limit, beforeSeq = null) {
   if (!store || !groupId || !(limit > 0)) return { messages: [], oldestSeq: null, hasMore: false };
 
@@ -902,6 +965,7 @@ async function routeEnvelopeToVpThread(groupId, vpId, envelope) {
       threadId: thread.threadId,
       role: envelope?.msg?.meta?.injectedBy === 'route_forward' ? 'assistant' : 'user',
       speakerVpId: envelope?.msg?.meta?.senderVpId || envelope?.msg?.from || null,
+      attachments: Array.isArray(envelope?.msg?.meta?.attachments) ? envelope.msg.meta.attachments : [],
     });
     thread.updatedAt = Date.now();
     try {
@@ -987,6 +1051,7 @@ function ensureDriverRunning(groupId, vpId, threadId = 'main') {
             threadId: thread.threadId,
             role: isForward ? 'assistant' : 'user',
             speakerVpId: senderVpId,
+            attachments: Array.isArray(meta.attachments) ? meta.attachments : [],
           });
         }
       } catch { /* never crash WS pipeline */ }
@@ -2857,17 +2922,17 @@ function appendTurnToGroupHistory(groupId, threadId, prompts, assistantTextParts
  * Best-effort: a write failure does NOT abort the turn — engines can
  * still run, and the next user message will trigger another append.
  *
- * Note: we mirror `engine.#persistMessages`'s schema for the user row
- * exactly (role/content/threadId/groupId), so existing parsers /
- * loaders see no schema drift. Attachments are not part of the on-disk
- * schema today (the engine never wrote them either) — they live on the
- * coordinator's jsonl-log under group meta.
+ * Note: we mirror `engine.#persistMessages`'s core user-row fields
+ * (role/content/threadId/groupId) so existing parsers keep working.
+ * Attachment UI metadata is persisted separately (without base64) so
+ * refresh replay can render chips without leaking image source data into
+ * the message body.
  *
- * @param {{ msgId:string, text:string, groupId:string, role?:string, speakerVpId?:string|null }} args
+ * @param {{ msgId:string, text:string, groupId:string, role?:string, speakerVpId?:string|null, attachments?:Array<object> }} args
  * @returns {boolean} true if this call wrote the row, false if a prior
  *   call already wrote it (dedup hit).
  */
-function persistInboundMessageOnceByMsgId({ msgId, text, groupId, threadId = 'main', role, speakerVpId }) {
+function persistInboundMessageOnceByMsgId({ msgId, text, groupId, threadId = 'main', role, speakerVpId, attachments }) {
   if (!session?.conversationStore) return false;
   // No msgId means no dedup key — caller is responsible for guarding.
   // Both call sites already do (`if (envMsgId && text)` and
@@ -2918,6 +2983,9 @@ function persistInboundMessageOnceByMsgId({ msgId, text, groupId, threadId = 'ma
     if (persistRole === 'assistant' && speakerVpId && typeof speakerVpId === 'string') {
       record.speakerVpId = speakerVpId;
     }
+    if (persistRole === 'user' && Array.isArray(attachments) && attachments.length > 0) {
+      record.attachments = attachments;
+    }
     session.conversationStore.append(record);
     return true;
   } catch (err) {
@@ -3357,21 +3425,25 @@ export async function handleUnifyFetchToolStats(_msg = {}) {
  */
 export async function handleUnifyFetchDebugHistory(msg = {}) {
   const limit = Number.isFinite(msg?.limit) ? Number(msg.limit) : 100;
+  const dreamLimit = Number.isFinite(msg?.dreamLimit) ? Number(msg.dreamLimit) : 5;
   const groupId = typeof msg?.groupId === 'string' && msg.groupId ? msg.groupId : null;
   const threadId = typeof msg?.threadId === 'string' && msg.threadId ? msg.threadId : null;
   let loops = [];
   let turns = [];
+  let dreamEvents = [];
   try {
     if (session?.trace && typeof session.trace.fetchRecentDebugHistory === 'function') {
-      const out = session.trace.fetchRecentDebugHistory({ limit, groupId, threadId });
+      const out = session.trace.fetchRecentDebugHistory({ limit, dreamLimit, groupId, threadId });
       loops = Array.isArray(out?.loops) ? out.loops : [];
       turns = Array.isArray(out?.turns) ? out.turns : [];
+      dreamEvents = Array.isArray(out?.dreamEvents) ? out.dreamEvents : [];
     }
   } catch (err) {
     sendToServer({
       type: 'unify_debug_history',
       loops: [],
       turns: [],
+      dreamEvents: [],
       error: err && err.message ? err.message : String(err),
     });
     return;
@@ -3380,6 +3452,7 @@ export async function handleUnifyFetchDebugHistory(msg = {}) {
     type: 'unify_debug_history',
     loops,
     turns,
+    dreamEvents,
     groupId,
     threadId,
   });
@@ -3493,7 +3566,15 @@ export async function handleUnifyLoadHistory(msg) {
 
   for (const entry of replayEntries) {
     if (entry.role === 'user') {
-      sendUnifyOutput({ type: 'user', message: { content: entry.content, id: entry.id || null }, ts: entry.ts || null }, { groupId: entry.groupId || null });
+      sendUnifyOutput({
+        type: 'user',
+        message: {
+          content: entry.content,
+          id: entry.id || null,
+          ...(Array.isArray(entry.attachments) && entry.attachments.length > 0 ? { attachments: hydrateHistoryAttachmentPreviews(entry.attachments) } : {}),
+        },
+        ts: entry.ts || null,
+      }, { groupId: entry.groupId || null });
     } else if (entry.role === 'assistant') {
       // speakerVpId rides on the envelope so the frontend can route this
       // replayed assistant text to the correct VP track. Without it, the
@@ -3584,6 +3665,7 @@ export async function handleUnifyLoadMoreHistory(msg) {
       role: m.role,
       content: m.content,
       groupId: m.groupId || null,
+      ...(Array.isArray(m.attachments) && m.attachments.length > 0 ? { attachments: hydrateHistoryAttachmentPreviews(m.attachments) } : {}),
       ...(m.speakerVpId ? { speakerVpId: m.speakerVpId } : {}),
     }));