Fix sidebar history merge titles

jasonczc · HAQI · jasonczc · commit 5085f79f6f76 · 2026-05-08T17:19:34.000+09:00
via [HAQI](https://hapi.run) Co-Authored-By: HAQI <noreply@hapi.run>
diff --git a/hub/src/store/messages.test.ts b/hub/src/store/messages.test.ts
@@ -0,0 +1,90 @@
+import { describe, expect, it } from 'bun:test'
+
+import { Store } from './index'
+
+const uploadPath = '/var/folders/tmp/hapi-blobs/session-abc/1778226295654-image.webp'
+
+function userMessage(text: string, options?: {
+    sentFrom?: string
+    attachments?: Array<{ id: string; filename: string; mimeType: string; size: number; path: string; previewUrl?: string }>
+}): unknown {
+    return {
+        role: 'user',
+        content: {
+            type: 'text',
+            text,
+            attachments: options?.attachments
+        },
+        meta: options?.sentFrom ? { sentFrom: options.sentFrom } : undefined
+    }
+}
+
+function agentMessage(text: string): unknown {
+    return {
+        role: 'agent',
+        content: {
+            type: 'output',
+            data: {
+                type: 'assistant',
+                message: {
+                    role: 'assistant',
+                    content: [{ type: 'text', text }]
+                }
+            }
+        }
+    }
+}
+
+function getText(content: unknown): string {
+    const record = content as { content?: { text?: string } }
+    return record.content?.text ?? ''
+}
+
+function createSessionPair(store: Store): { sourceId: string; targetId: string } {
+    const source = store.sessions.getOrCreateSession('source', { path: '/tmp/source' }, null, 'default')
+    const target = store.sessions.getOrCreateSession('target', { path: '/tmp/target' }, null, 'default')
+    return { sourceId: source.id, targetId: target.id }
+}
+
+describe('copySessionMessages', () => {
+    it('skips cli upload-path echoes when canonical attachment message exists', () => {
+        const store = new Store(':memory:')
+        const { sourceId, targetId } = createSessionPair(store)
+
+        store.messages.addMessage(sourceId, userMessage('please inspect this', {
+            sentFrom: 'webapp',
+            attachments: [{
+                id: 'att-1',
+                filename: 'image.webp',
+                mimeType: 'image/webp',
+                size: 123,
+                path: uploadPath,
+                previewUrl: 'data:image/webp;base64,abc'
+            }]
+        }))
+        store.messages.addMessage(sourceId, userMessage(`@${uploadPath}\n\nplease inspect this`, { sentFrom: 'cli' }))
+        store.messages.addMessage(sourceId, agentMessage('done'))
+
+        const result = store.messages.copySessionMessages(sourceId, targetId)
+        const copied = store.messages.getMessages(targetId)
+
+        expect(result.copied).toBe(2)
+        expect(copied).toHaveLength(2)
+        expect(getText(copied[0]!.content)).toBe('please inspect this')
+        expect(copied.map((message) => getText(message.content))).not.toContain(`@${uploadPath}\n\nplease inspect this`)
+    })
+
+    it('redacts orphan cli upload paths instead of copying absolute temp paths', () => {
+        const store = new Store(':memory:')
+        const { sourceId, targetId } = createSessionPair(store)
+
+        store.messages.addMessage(sourceId, userMessage(`@${uploadPath}\n\nwhat is in this image?`, { sentFrom: 'cli' }))
+
+        const result = store.messages.copySessionMessages(sourceId, targetId)
+        const copied = store.messages.getMessages(targetId)
+
+        expect(result.copied).toBe(1)
+        expect(copied).toHaveLength(1)
+        expect(getText(copied[0]!.content)).toBe('@[1778226295654-image.webp]\n\nwhat is in this image?')
+    })
+})
diff --git a/hub/src/store/messages.ts b/hub/src/store/messages.ts
@@ -14,6 +14,105 @@ type DbMessageRow = {
     local_id: string | null
 }
 
+
+type JsonRecord = Record<string, unknown>
+
+function isRecord(value: unknown): value is JsonRecord {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+}
+
+function getUserMessageText(content: unknown): string | null {
+    if (!isRecord(content)) return null
+    if (content.role !== 'user') return null
+    const inner = content.content
+    if (!isRecord(inner)) return null
+    if (inner.type !== 'text') return null
+    return typeof inner.text === 'string' ? inner.text : null
+}
+
+function getSentFrom(content: unknown): string | null {
+    if (!isRecord(content)) return null
+    const meta = content.meta
+    if (!isRecord(meta)) return null
+    return typeof meta.sentFrom === 'string' ? meta.sentFrom : null
+}
+
+function getAttachmentPaths(content: unknown): string[] {
+    if (!isRecord(content)) return []
+    if (content.role !== 'user') return []
+    const inner = content.content
+    if (!isRecord(inner) || !Array.isArray(inner.attachments)) return []
+
+    const paths: string[] = []
+    for (const item of inner.attachments) {
+        if (isRecord(item) && typeof item.path === 'string' && item.path.length > 0) {
+            paths.push(item.path)
+        }
+    }
+    return paths
+}
+
+const HAPI_BLOBS_PATH_PATTERN = /@([^\s"'`<>()]*[/\\]hapi-blobs[/\\][^\s"'`<>()]+)/g
+
+function extractHapiBlobReferences(text: string): string[] {
+    return Array.from(text.matchAll(HAPI_BLOBS_PATH_PATTERN), (match) => match[1] ?? '')
+        .filter((path) => path.length > 0)
+}
+
+function basename(path: string): string {
+    return path.split(/[/\\]/).filter(Boolean).pop() ?? 'upload'
+}
+
+function sanitizeHapiBlobReferences(text: string): string {
+    return text.replace(HAPI_BLOBS_PATH_PATTERN, (_match, path: string) => `@[${basename(path)}]`)
+}
+
+function withUserMessageText(content: unknown, text: string): unknown {
+    if (!isRecord(content)) return content
+    const inner = content.content
+    if (!isRecord(inner)) return content
+    return {
+        ...content,
+        content: {
+            ...inner,
+            text
+        }
+    }
+}
+
+function buildCopiedMessageRows(rows: DbMessageRow[]): Array<{ row: DbMessageRow; content: string }> {
+    const canonicalAttachmentPaths = new Set<string>()
+    for (const row of rows) {
+        const parsed = safeJsonParse(row.content)
+        for (const path of getAttachmentPaths(parsed)) {
+            canonicalAttachmentPaths.add(path)
+        }
+    }
+
+    const copied: Array<{ row: DbMessageRow; content: string }> = []
+    for (const row of rows) {
+        const parsed = safeJsonParse(row.content)
+        const text = getUserMessageText(parsed)
+        const hapiBlobRefs = text ? extractHapiBlobReferences(text) : []
+
+        if (text && getSentFrom(parsed) === 'cli' && hapiBlobRefs.length > 0) {
+            if (hapiBlobRefs.some((path) => canonicalAttachmentPaths.has(path))) {
+                continue
+            }
+
+            copied.push({
+                row,
+                content: JSON.stringify(withUserMessageText(parsed, sanitizeHapiBlobReferences(text)))
+            })
+            continue
+        }
+
+        copied.push({ row, content: row.content })
+    }
+
+    return copied
+}
+
 function toStoredMessage(row: DbMessageRow): StoredMessage {
     return {
         id: row.id,
@@ -203,27 +302,28 @@ export function copySessionMessages(
             ).run(oldMaxSeq, toSessionId)
         }
 
-        const result = db.prepare(`
+        const sourceRows = db.prepare(
+            'SELECT * FROM messages WHERE session_id = ? ORDER BY seq ASC'
+        ).all(fromSessionId) as DbMessageRow[]
+        const copiedRows = buildCopiedMessageRows(sourceRows)
+        const insert = db.prepare(`
             INSERT INTO messages (id, session_id, content, created_at, seq, local_id)
-            SELECT
-                lower(hex(randomblob(16))),
-                @to_session_id,
-                content,
-                created_at,
-                seq,
-                NULL
-            FROM messages
-            WHERE session_id = @from_session_id
-            ORDER BY seq ASC
-        `).run({
-            to_session_id: toSessionId,
-            from_session_id: fromSessionId
-        })
+            VALUES (lower(hex(randomblob(16))), @session_id, @content, @created_at, @seq, NULL)
+        `)
+
+        for (const item of copiedRows) {
+            insert.run({
+                session_id: toSessionId,
+                content: item.content,
+                created_at: item.row.created_at,
+                seq: item.row.seq
+            })
+        }
 
         rebuildSessionConversationTurns(db, toSessionId)
 
         db.exec('COMMIT')
-        return { copied: result.changes, oldMaxSeq, newMaxSeq }
+        return { copied: copiedRows.length, oldMaxSeq, newMaxSeq }
     } catch (error) {
         db.exec('ROLLBACK')
         throw error
diff --git a/hub/src/sync/sessionCache.ts b/hub/src/sync/sessionCache.ts
@@ -5,6 +5,24 @@ import { clampAliveTime } from './aliveTime'
 import { EventPublisher } from './eventPublisher'
 import { extractTodoWriteTodosFromMessageContent, TodosSchema } from './todos'
 
+const HAPI_BLOBS_METADATA_PATH_PATTERN = /@([^\s"'`<>()]*[/\\]hapi-blobs[/\\][^\s"'`<>()]+)/g
+
+function sanitizeMetadataDisplayText(value: string): string {
+    return value
+        .replace(HAPI_BLOBS_METADATA_PATH_PATTERN, '')
+        .replace(/\s+/g, ' ')
+        .trim()
+}
+
+function sanitizeSummary(value: unknown): unknown | undefined {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) return value
+    const summary = value as Record<string, unknown>
+    if (typeof summary.text !== 'string') return value
+    const text = sanitizeMetadataDisplayText(summary.text)
+    if (!text) return undefined
+    return text === summary.text ? value : { ...summary, text }
+}
+
 export class SessionCache {
     private readonly sessions: Map<string, Session> = new Map()
     private readonly lastBroadcastAtBySessionId: Map<string, number> = new Map()
@@ -478,17 +496,23 @@ export class SessionCache {
         let changed = false
 
         if (typeof oldObj.name === 'string' && typeof newObj.name !== 'string') {
-            merged.name = oldObj.name
-            changed = true
+            const name = sanitizeMetadataDisplayText(oldObj.name)
+            if (name) {
+                merged.name = name
+                changed = true
+            }
         }
 
         const oldSummary = oldObj.summary as { text?: unknown; updatedAt?: unknown } | undefined
         const newSummary = newObj.summary as { text?: unknown; updatedAt?: unknown } | undefined
         const oldUpdatedAt = typeof oldSummary?.updatedAt === 'number' ? oldSummary.updatedAt : null
         const newUpdatedAt = typeof newSummary?.updatedAt === 'number' ? newSummary.updatedAt : null
         if (oldUpdatedAt !== null && (newUpdatedAt === null || oldUpdatedAt > newUpdatedAt)) {
-            merged.summary = oldSummary
-            changed = true
+            const summary = sanitizeSummary(oldSummary)
+            if (summary) {
+                merged.summary = summary
+                changed = true
+            }
         }
 
         if (oldObj.worktree && !newObj.worktree) {
diff --git a/hub/src/sync/syncEngine.ts b/hub/src/sync/syncEngine.ts
@@ -98,6 +98,15 @@ const NOTE_REFRESH_TASK_PREFIX = 'note-refresh:'
 const MAX_NOTE_REFRESH_CONTENT_LENGTH = 20_000
 const MAX_GROUP_MIRROR_TEXT_LENGTH = 8_000
 const GROUP_NOTE_FILE_SYNC_INTERVAL_MS = 3 * 60 * 1000
+
+const HAPI_BLOBS_DISPLAY_PATH_PATTERN = /@([^\s"'`<>()]*[/\\]hapi-blobs[/\\][^\s"'`<>()]+)/g
+
+function sanitizeSessionDisplayText(value: string): string {
+    return value
+        .replace(HAPI_BLOBS_DISPLAY_PATH_PATTERN, '')
+        .replace(/\s+/g, ' ')
+        .trim()
+}
 const CODEX_TOOL_PROCESS_EVENT_TYPES = new Set([
     'tool-call',
     'tool-call-result',
@@ -2054,12 +2063,14 @@ ${note.content}
 
         const name = metadata.name?.trim()
         if (name) {
-            return name
+            const title = sanitizeSessionDisplayText(name)
+            if (title) return title
         }
 
         const summary = metadata.summary?.text?.trim()
         if (summary) {
-            return summary
+            const title = sanitizeSessionDisplayText(summary)
+            if (title) return title
         }
 
         const path = metadata.path?.trim()
diff --git a/web/src/lib/session-title.test.ts b/web/src/lib/session-title.test.ts
@@ -0,0 +1,19 @@
+import { describe, expect, it } from 'vitest'
+import { getSessionTitle, sanitizeSessionDisplayText } from '@/lib/session-title'
+
+describe('session-title', () => {
+    it('removes copied hapi blob paths from display text', () => {
+        const text = '@/var/folders/tmp/hapi-blobs/session/image.webp\n\n继续检查侧边栏'
+        expect(sanitizeSessionDisplayText(text)).toBe('继续检查侧边栏')
+    })
+
+    it('falls back when metadata title only contains a hapi blob path', () => {
+        expect(getSessionTitle({
+            id: 'session_abcdef',
+            metadata: {
+                summary: { text: '@/var/folders/tmp/hapi-blobs/session/image.webp' },
+                path: '/Users/jasonczc/workspace/haqi'
+            }
+        })).toBe('haqi')
+    })
+})
diff --git a/web/src/lib/session-title.ts b/web/src/lib/session-title.ts
@@ -2,6 +2,22 @@ import type { Session, SessionSummary } from '@/types/api'
 
 type SessionLike = Pick<SessionSummary, 'id' | 'metadata'> | Pick<Session, 'id' | 'metadata'>
 
+const HAPI_BLOBS_TITLE_PATH_PATTERN = /@([^\s"'`<>()]*[/\\]hapi-blobs[/\\][^\s"'`<>()]+)/g
+
+export function sanitizeSessionDisplayText(value: string): string {
+    return value
+        .replace(HAPI_BLOBS_TITLE_PATH_PATTERN, '')
+        .replace(/\s+/g, ' ')
+        .trim()
+}
+
+function cleanTitleCandidate(value: string | undefined): string | undefined {
+    const trimmed = value?.trim() ?? ''
+    if (!trimmed) return undefined
+    const sanitized = sanitizeSessionDisplayText(trimmed)
+    return sanitized || undefined
+}
+
 export function getSessionTitle(
     session: SessionLike | null | undefined,
     options?: {
@@ -10,12 +26,12 @@ export function getSessionTitle(
     }
 ): string {
     const fallbackIdLength = options?.fallbackIdLength ?? 8
-    const name = session?.metadata?.name?.trim()
+    const name = cleanTitleCandidate(session?.metadata?.name)
     if (name) {
         return name
     }
 
-    const summaryText = session?.metadata?.summary?.text?.trim()
+    const summaryText = cleanTitleCandidate(session?.metadata?.summary?.text)
     if (summaryText) {
         return summaryText
     }
diff --git a/web/src/router.tsx b/web/src/router.tsx
