fix: store inline prosemirror JSON in ChatMessage.message (HULY-20)

The original attempt (PR #44, reverted in #45) called uploadMarkup and
stored a MarkupBlobRef string in `message`. That rendered as literal
text in the web UI because the front-end's MessageViewer component does:

    $: node = markupToJSON(message)

with no MarkupBlobRef resolution step. ChatMessage.message is typed
`TypeMarkup()` — an inline prosemirror-JSON string (`Markup = string`
in @hcengineering/core), not a MarkupBlobRef.

Why the same pattern appeared to work for Issue.description:
Issue.description is also `TypeMarkup()`, but the web UI renders it
through `<CollaborativeTextEditor>`, which DOES resolve MarkupBlobRef
via the collaborator service. So `huly issue update --body` accidentally
worked. The chat/dm/thread/activity paths render through plain
`MessageViewer` and broke.

Fix:
  * Convert HTML → prosemirror JSON locally via the existing
    `htmlToMarkup()` helper.
  * Store the resulting prosemirror-JSON string inline in `message`
    — no blob upload, no MarkupBlobRef.
  * Same pattern applied to all 10 chat-message write paths:
    comment add/update, channel message send/update, thread reply
    add/update, dm message send, activity reply add/update,
    approval comment.

Removed from the previous PR (no longer relevant):
  * `uploadMarkup` and `generateId` imports — not used anymore.
  * Deferred-upload pattern for dry-run on channel paths — dry-run
    preview now shows the converted prosemirror JSON (which is what
    would be stored). No external IO involved in conversion, so no
    point deferring.
  * `wouldUploadMarkup` notes in dry-run output — n/a, no upload.

Verified on https://huly.aaravlabs.com (real server):
  * Posted via the local build: `node dist/index.js comment add --issue
    HULY-20 --body-file /tmp/kilo/huly20-fix2.html`.
  * message field stores inline prosemirror JSON starting with
    `{"type":"doc","content":[{"type":"heading",...}]}`.
  * Web UI's MessageViewer can render this directly without any
    collaborator lookup.

Author: IamCoder18

packages/cli/src/resources/activity.ts

@@ -18,6 +18,7 @@ import {
 } from '../output/format.js'
 import { withSpinner } from '../output/progress.js'
 import { CliError, ExitCode } from '../output/errors.js'
+import { htmlToMarkup } from './_helpers.js'
 
 type ActivityMessage = Doc & {
   message?: string
@@ -371,7 +372,11 @@ export async function addReply(opts: ReplyOpts): Promise<void> {
   const client = await connectCli({ url: opts.url, workspace: opts.workspace })
   try {
     const { id, doc } = await fetchActivity(client, opts.target)
-    const data: Record<string, unknown> = { message: opts.body }
+    // HULY-20: ActivityMessage.message is TypeMarkup (inline prosemirror
+    // JSON string). Convert HTML → prosemirror locally and store inline,
+    // NOT a MarkupBlobRef — the web UI renders via MessageViewer which
+    // calls markupToJSON(message) directly with no collaborator lookup.
+    const data: Record<string, unknown> = { message: htmlToMarkup(opts.body) }
     const rid = await withSpinner(
       'Replying…',
       () =>
@@ -408,11 +413,12 @@ export async function updateReply(
     // attachedTo pointing at the parent). `message` lives on the reply
     // doc itself — updateDoc, NOT updateCollection against the parent's
     // 'replies' tuple (which doesn't exist).
+    // HULY-20: inline prosemirror JSON, same as addReply.
     await client.updateDoc(
       ACTIVITY_CLASS,
       doc.space as unknown as Ref<Space>,
       id as Ref<Doc>,
-      { message: opts.body, modifiedOn: Date.now() } as any,
+      { message: htmlToMarkup(opts.body), modifiedOn: Date.now() } as any,
     )
     updated('updated reply', refString(id))
   } finally {

packages/cli/src/resources/approvals.ts

@@ -18,6 +18,7 @@ import {
 } from '../output/format.js'
 import { withSpinner } from '../output/progress.js'
 import { CliError, ExitCode } from '../output/errors.js'
+import { htmlToMarkup } from './_helpers.js'
 
 const REQUEST_STATUSES = ['Active', 'Completed', 'Rejected', 'Cancelled'] as const
 type RequestStatus = (typeof REQUEST_STATUSES)[number]
@@ -297,7 +298,10 @@ export async function commentOnApproval(opts: CommentOpts): Promise<void> {
   const client = await connectCli({ url: opts.url, workspace: opts.workspace })
   try {
     const { id, doc } = await fetchRequest(client, opts.ref!)
-    const data: Record<string, unknown> = { message: opts.body }
+    // HULY-20: approval comments are ChatMessage instances — message is
+    // TypeMarkup (inline prosemirror JSON). Inline storage, same as
+    // chat comments.
+    const data: Record<string, unknown> = { message: htmlToMarkup(opts.body) }
     if (opts.decision) data.decision = opts.decision
     const cid = await withSpinner(
       'Commenting…',

packages/cli/src/resources/channel.ts

@@ -6,6 +6,7 @@ import { normalizeSocialKey } from '../auth/social.js'
 import { shouldJson, json, table, COLUMNS, C, success, updated, bulkRemoved } from '../output/format.js'
 import { withSpinner } from '../output/progress.js'
 import { CliError, ExitCode } from '../output/errors.js'
+import { htmlToMarkup } from './_helpers.js'
 
 type Channel = Doc & {
   name: string
@@ -546,8 +547,12 @@ export async function sendChannelMessage(
   const client = await connectCli({ url: opts.url, workspace: opts.workspace })
   try {
     const channel = await resolveChannel(client, ref)
+    // HULY-20: ChatMessage.message is TypeMarkup (inline prosemirror JSON
+    // string), rendered via MessageViewer with no collaborator lookup. Store
+    // the converted prosemirror-JSON string inline — NOT a MarkupBlobRef.
+    const messageMarkup = htmlToMarkup(body)
     const data: Record<string, unknown> = {
-      message: body,
+      message: messageMarkup,
     }
     if (opts.dryRun) {
       console.log('would send channel message:')
@@ -610,8 +615,10 @@ export async function updateChannelMessage(
     if (msg.attachedTo !== channel._id) {
       throw new CliError(ExitCode.NotFound, 'message does not belong to this channel')
     }
+    // HULY-20: inline prosemirror, same as sendChannelMessage.
+    const messageMarkup = htmlToMarkup(body)
     const data: Record<string, unknown> = {
-      message: body,
+      message: messageMarkup,
       editedOn: Date.now(),
     }
     if (opts.dryRun) {
@@ -737,8 +744,11 @@ export async function addThreadReply(
   try {
     const parent = await client.findOne(CHAT_MESSAGE_CLASS, { _id: targetId as Ref<ChatMessage> })
     if (!parent) throw new CliError(ExitCode.NotFound, `target message ${targetId} not found`)
+    // HULY-20: ThreadMessage.message is TypeMarkup (inline prosemirror
+    // JSON string). Inline storage, same as channel/dm messages.
+    const messageMarkup = htmlToMarkup(body)
     const data: Record<string, unknown> = {
-      message: body,
+      message: messageMarkup,
     }
     if (opts.dryRun) {
       console.log('would add thread reply:')
@@ -791,7 +801,9 @@ export async function updateThreadReply(
       _id: replyId as Ref<ChatMessage>,
     })
     if (!reply) throw new CliError(ExitCode.NotFound, `thread reply ${replyId} not found`)
-    const data: Record<string, unknown> = { message: body, editedOn: Date.now() }
+    // HULY-20: inline prosemirror, same as addThreadReply.
+    const messageMarkup = htmlToMarkup(body)
+    const data: Record<string, unknown> = { message: messageMarkup, editedOn: Date.now() }
     if (opts.dryRun) {
       console.log(`would update thread reply ${replyId}:`)
       console.log(
@@ -1039,7 +1051,10 @@ export async function sendDmMessage(
     })
     const dm = await client.findOne(DM_CLASS, { _id: dmId as Ref<DirectMessage> })
     if (!dm) throw new CliError(ExitCode.NotFound, `DM ${dmRef} not found`)
-    const data: Record<string, unknown> = { message: body }
+    // HULY-20: DM messages are ChatMessage instances — message is TypeMarkup
+    // (inline prosemirror JSON). Inline storage, same as channel messages.
+    const messageMarkup = htmlToMarkup(body)
+    const data: Record<string, unknown> = { message: messageMarkup }
     if (opts.dryRun) {
       console.log('would send DM:')
       console.log(

packages/cli/src/resources/comment.ts

@@ -6,6 +6,7 @@ import { shouldJson, json, table, COLUMNS, success, updated, bulkRemoved } from
 import { withSpinner } from '../output/progress.js'
 import { CliError, ExitCode } from '../output/errors.js'
 import { readEnv } from '../auth/env.js'
+import { htmlToMarkup } from './_helpers.js'
 
 type ChatMessage = Doc & {
   message: string
@@ -85,6 +86,15 @@ export async function addComment(opts: {
     })
     const issue = await client.findOne(CLASS.Issue as Ref<Class<Doc>>, { _id: issueId })
     if (!issue) throw new CliError(ExitCode.NotFound, `issue ${opts.issue} not found`)
+    // HULY-20: ChatMessage.message is typed `TypeMarkup()` (inline
+    // prosemirror-JSON string). The web UI renders it via MessageViewer,
+    // which calls `markupToJSON(message)` directly with NO collaborator
+    // resolution — so storing a MarkupBlobRef string in `message` would
+    // render as literal text. Convert HTML → prosemirror JSON locally and
+    // store the JSON string inline. (Document.content uses
+    // TypeCollaborativeDoc and stores a MarkupBlobRef, but that's a
+    // different attribute type and a different UI renderer.)
+    const messageMarkup = htmlToMarkup(body)
     const id = await withSpinner(
       'Adding comment…',
       () =>
@@ -94,13 +104,13 @@ export async function addComment(opts: {
           issueId,
           CLASS.Issue,
           'comments',
-          { message: body } as any,
+          { message: messageMarkup } as any,
         ),
       opts,
     )
     invalidateIndex(client, CLASS.ChatMessage)
     if (shouldJson({ json: opts.json, ci: opts.ci })) {
-      json({ _id: id, attachedTo: issueId, message: body })
+      json({ _id: id, attachedTo: issueId, message: messageMarkup })
     } else {
       success('added comment', `on ${opts.issue}`, id)
     }
@@ -130,14 +140,17 @@ export async function updateComment(
     })
     const comment = await client.findOne(CLASS.ChatMessage as Ref<Class<ChatMessage>>, { _id: commentId })
     if (!comment) throw new CliError(ExitCode.NotFound, `comment ${ref} not found`)
+    // HULY-20: same inline-prosemirror conversion as addComment. Storing a
+    // MarkupBlobRef string here would render as literal text in the web UI.
+    const messageMarkup = htmlToMarkup(body)
     await withSpinner(
       'Updating comment…',
       () =>
         client.updateDoc(
           CLASS.ChatMessage as Ref<Class<ChatMessage>>,
           (comment as Doc).space as Ref<Doc>,
           commentId as Ref<Doc>,
-          { message: body, editedOn: Date.now() } as any,
+          { message: messageMarkup, editedOn: Date.now() } as any,
         ),
       opts,
     )