Add Send to channel for thread messages

desktop/src/features/channels/ui/ChannelPane.tsx

@@ -131,6 +131,7 @@ export const ChannelPane = React.memo(function ChannelPane({
   onResetThreadPanelWidth,
   onSelectThreadReplyTarget,
   onSendMessage,
+  onSendToChannel,
   onSendVideoReviewComment,
   onSendThreadReply,
   onThreadScrollTargetResolved,
@@ -295,9 +296,7 @@ export const ChannelPane = React.memo(function ChannelPane({
     onEdit(target);
     return true;
   }, [findLastOwnEditable, onEdit, threadHeadMessage, threadMessages]);
-
   const timeoutState = useTimeoutState();
-
   // A moderation DM (1:1 with the relay identity) is read-only for the member;
   // only DMs pay for the NIP-11 `self` lookup. Fails open: no `relaySelf` →
   // ordinary DM, composer enabled.
@@ -874,6 +873,9 @@ export const ChannelPane = React.memo(function ChannelPane({
                 onExpandReplies={onExpandThreadReplies}
                 onSelectReplyTarget={onSelectThreadReplyTarget}
                 onSend={onSendThreadReply}
+                onSendToChannel={
+                  isComposerDisabled ? undefined : onSendToChannel
+                }
                 onScrollTargetResolved={() => resolveScrollTarget()}
                 onScrollTargetSettled={resolveScrollTarget}
                 onToggleReaction={onToggleReaction}

desktop/src/features/channels/ui/ChannelPane.types.ts

@@ -107,6 +107,11 @@ export type ChannelPaneProps = {
     mediaTags?: string[][],
     channelId?: string | null,
   ) => Promise<void>;
+  onSendToChannel: (
+    message: TimelineMessage,
+    threadRoot: TimelineMessage,
+    channelId: string,
+  ) => Promise<void>;
   onSendVideoReviewComment?: (
     message: TimelineMessage,
     content: string,

desktop/src/features/channels/ui/ChannelScreen.tsx

@@ -84,8 +84,7 @@ import { useChannelRouteTarget } from "./useChannelRouteTarget";
 import { useChannelOpenReadState } from "./useChannelOpenReadState";
 import { useChannelUnreadState } from "./useChannelUnreadState";
 import type { ChannelScreenProps } from "./ChannelScreen.types";
-const HEADER_ACTIONS_COMPACT_BREAKPOINT_PX = 760,
-  EMPTY_RELAY_EVENTS: RelayEvent[] = [];
+const EMPTY_RELAY_EVENTS: RelayEvent[] = [];
 export function ChannelScreen({
   activeChannel,
   autoSendDraftKey,
@@ -495,6 +494,7 @@ export function ChannelScreen({
     handleExpandThreadReplies,
     handleOpenThread,
     handleSendMessage,
+    handleSendToChannel,
     handleSendThreadReply,
     handleSelectThreadReplyTarget,
     handleToggleReaction,
@@ -713,7 +713,7 @@ export function ChannelScreen({
   const shouldCompactHeaderActions =
     hasAuxiliaryPanel &&
     channelContentWidthPx > 0 &&
-    channelContentWidthPx < HEADER_ACTIONS_COMPACT_BREAKPOINT_PX;
+    channelContentWidthPx < 760;
   const channelHeaderChromeRef = useMeasuredCssVariable({
     targetRef: mainInsetRef,
     ...channelContentTopPaddingMeasurement,
@@ -940,6 +940,7 @@ export function ChannelScreen({
                   onOpenThread={handleOpenThreadAndCloseAgentSession}
                   onSelectThreadReplyTarget={handleSelectThreadReplyTarget}
                   onSendMessage={handleSendMessage}
+                  onSendToChannel={handleSendToChannel}
                   onSendVideoReviewComment={effectiveSendVideoReviewComment}
                   onSendThreadReply={handleSendThreadReply}
                   onThreadScrollTargetResolved={

desktop/src/features/channels/useChannelPaneHandlers.ts

@@ -7,6 +7,7 @@ import type {
   useToggleReactionMutation,
 } from "@/features/messages/hooks";
 import { resolveThreadReplyTarget } from "@/features/messages/hooks";
+import { summarizeThreadRoot } from "@/features/messages/lib/sentFromThread";
 import type { TimelineMessage } from "@/features/messages/types";
 
 /**
@@ -287,6 +288,22 @@ export function useChannelPaneHandlers({
     [],
   );
 
+  const handleSendToChannel = React.useCallback(
+    async (
+      message: TimelineMessage,
+      threadRoot: TimelineMessage,
+      channelId: string,
+    ) => {
+      await sendMutateRef.current({
+        channelId,
+        content: message.body,
+        sentFromThreadRootExcerpt: summarizeThreadRoot(threadRoot.body),
+        sentFromThreadRootId: threadRoot.id,
+      });
+    },
+    [],
+  );
+
   const handleSendThreadReply = React.useCallback(
     async (
       content: string,
@@ -376,6 +393,7 @@ export function useChannelPaneHandlers({
     handleExpandThreadReplies,
     handleOpenThread,
     handleSendMessage,
+    handleSendToChannel,
     handleSendThreadReply,
     handleSelectThreadReplyTarget,
     handleToggleReaction,

desktop/src/features/messages/hooks.ts

@@ -27,6 +27,7 @@ import {
 export { mergeMessages, mergeTimelineCacheMessages };
 import { splitOutgoingTags } from "@/features/messages/lib/imetaMediaMarkdown";
 import { messageMentionPubkeys } from "@/features/messages/lib/messageMentionPubkeys";
+import { buildSentFromThreadTag } from "@/features/messages/lib/sentFromThread";
 import {
   clearTimeoutState,
   recordTimeoutFromRejection,
@@ -87,6 +88,8 @@ export function createOptimisticMessage(
   mentionPubkeys: string[] = [],
   parentEventId: string | null = null,
   mediaTags: string[][] = [],
+  sentFromThreadRootId: string | null = null,
+  sentFromThreadRootExcerpt: string | null = null,
 ): RelayEvent {
   const localKey = `optimistic-${crypto.randomUUID()}`;
   const tags: string[][] = [];
@@ -115,6 +118,11 @@ export function createOptimisticMessage(
   for (const tag of mediaTags) {
     tags.push(tag);
   }
+  if (sentFromThreadRootId) {
+    tags.push(
+      buildSentFromThreadTag(sentFromThreadRootId, sentFromThreadRootExcerpt),
+    );
+  }
 
   return {
     id: localKey,
@@ -413,6 +421,8 @@ export function useSendMessageMutation(
       mentionPubkeys?: string[];
       parentEventId?: string | null;
       mediaTags?: string[][];
+      sentFromThreadRootId?: string | null;
+      sentFromThreadRootExcerpt?: string | null;
     },
     MessageQueryContext | undefined
   >({
@@ -423,6 +433,8 @@ export function useSendMessageMutation(
       mentionPubkeys,
       parentEventId,
       mediaTags,
+      sentFromThreadRootId,
+      sentFromThreadRootExcerpt,
     }) => {
       // Prefer a channel captured by the caller at compose time. Otherwise,
       // resolve a captured id from the shared channel cache so navigation
@@ -465,6 +477,12 @@ export function useSendMessageMutation(
         identity.pubkey,
         mentionPubkeys,
       );
+      if (
+        sentFromThreadRootId &&
+        (parentEventId || imetaTags.length > 0 || emojiTags.length > 0)
+      ) {
+        throw new Error("A thread message can only be sent as top-level text.");
+      }
 
       // Messages carrying media OR custom-emoji tags MUST go through REST so
       // the relay's tag validation runs. The WebSocket path emits no extra
@@ -537,7 +555,17 @@ export function useSendMessageMutation(
         effectiveChannel.id,
         content,
         recipientPubkeys,
-        mentionTags,
+        [
+          ...mentionTags,
+          ...(sentFromThreadRootId
+            ? [
+                buildSentFromThreadTag(
+                  sentFromThreadRootId,
+                  sentFromThreadRootExcerpt,
+                ),
+              ]
+            : []),
+        ],
       );
     },
     onMutate: async ({
@@ -547,6 +575,8 @@ export function useSendMessageMutation(
       mentionPubkeys,
       parentEventId,
       mediaTags,
+      sentFromThreadRootId,
+      sentFromThreadRootExcerpt,
     }) => {
       // Mirror mutationFn's target resolution so the optimistic message lands
       // in the cache for the same channel as the real send. A caller-supplied
@@ -582,6 +612,8 @@ export function useSendMessageMutation(
         mentionPubkeys ?? [],
         parentEventId ?? null,
         mediaTags ?? [],
+        sentFromThreadRootId ?? null,
+        sentFromThreadRootExcerpt ?? null,
       );
 
       const nextWindow = mergeLiveChannelWindowEvent(

desktop/src/features/messages/lib/canSendToChannel.test.mjs

@@ -0,0 +1,48 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  assertCanSendMessageToChannel,
+  canSendMessageToChannel,
+} from "./canSendToChannel.ts";
+
+const CURRENT = "a".repeat(64);
+const OWNED_AGENT = "b".repeat(64);
+const OTHER_PERSON = "c".repeat(64);
+const OTHER_AGENT = "d".repeat(64);
+
+const message = (pubkey) => ({ kind: 9, pubkey });
+const profiles = {
+  [OWNED_AGENT]: { isAgent: true, ownerPubkey: CURRENT },
+  [OTHER_AGENT]: { isAgent: true, ownerPubkey: OTHER_PERSON },
+};
+
+test("send-to-channel permits self-authored messages", () => {
+  assert.equal(
+    canSendMessageToChannel(message(CURRENT), CURRENT, profiles),
+    true,
+  );
+});
+
+test("send-to-channel permits messages from an agent owned by the viewer", () => {
+  assert.equal(
+    canSendMessageToChannel(message(OWNED_AGENT), CURRENT, profiles),
+    true,
+  );
+});
+
+test("send-to-channel rejects third-party people and agents", () => {
+  assert.equal(
+    canSendMessageToChannel(message(OTHER_PERSON), CURRENT, profiles),
+    false,
+  );
+  assert.equal(
+    canSendMessageToChannel(message(OTHER_AGENT), CURRENT, profiles),
+    false,
+  );
+  assert.throws(
+    () =>
+      assertCanSendMessageToChannel(message(OTHER_AGENT), CURRENT, profiles),
+    /only send your own or your agents' messages/,
+  );
+});

desktop/src/features/messages/lib/canSendToChannel.ts

@@ -0,0 +1,21 @@
+import { canManageMessageForCurrentUser } from "@/features/messages/lib/canManageMessage";
+import type { TimelineMessage } from "@/features/messages/types";
+import type { UserProfileLookup } from "@/features/profile/lib/identity";
+
+export function canSendMessageToChannel(
+  message: TimelineMessage,
+  currentPubkey: string | undefined,
+  profiles: UserProfileLookup | undefined,
+): boolean {
+  return canManageMessageForCurrentUser(message, currentPubkey, profiles);
+}
+
+export function assertCanSendMessageToChannel(
+  message: TimelineMessage,
+  currentPubkey: string | undefined,
+  profiles: UserProfileLookup | undefined,
+): void {
+  if (!canSendMessageToChannel(message, currentPubkey, profiles)) {
+    throw new Error("You can only send your own or your agents' messages.");
+  }
+}

desktop/src/features/messages/lib/sentFromThread.test.mjs

@@ -0,0 +1,69 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  buildSentFromThreadTag,
+  getSentFromThreadReference,
+  getSentFromThreadRootId,
+  SENT_FROM_THREAD_TAG,
+  summarizeThreadRoot,
+} from "./sentFromThread.ts";
+
+test("buildSentFromThreadTag records the normalized root event ID", () => {
+  assert.deepEqual(buildSentFromThreadTag("  root-event  "), [
+    SENT_FROM_THREAD_TAG,
+    "root-event",
+  ]);
+});
+
+test("buildSentFromThreadTag includes a normalized human excerpt", () => {
+  assert.deepEqual(buildSentFromThreadTag("root-event", "  Launch plan  "), [
+    SENT_FROM_THREAD_TAG,
+    "root-event",
+    "Launch plan",
+  ]);
+});
+
+test("buildSentFromThreadTag rejects an empty root event ID", () => {
+  assert.throws(
+    () => buildSentFromThreadTag("  "),
+    /thread root event ID is required/,
+  );
+});
+
+test("sent-from-thread references accept an optional excerpt", () => {
+  assert.equal(
+    getSentFromThreadRootId([
+      ["h", "channel-id"],
+      [SENT_FROM_THREAD_TAG, "root-event"],
+    ]),
+    "root-event",
+  );
+  assert.deepEqual(
+    getSentFromThreadReference([
+      [SENT_FROM_THREAD_TAG, "root-event", "Root summary"],
+    ]),
+    { rootEventId: "root-event", rootExcerpt: "Root summary" },
+  );
+  assert.equal(
+    getSentFromThreadRootId([
+      [SENT_FROM_THREAD_TAG, "root-event", "summary", "extra"],
+    ]),
+    null,
+  );
+  assert.equal(getSentFromThreadRootId([[SENT_FROM_THREAD_TAG, "  "]]), null);
+  assert.equal(getSentFromThreadRootId(undefined), null);
+});
+
+test("summarizeThreadRoot keeps concise text and ignores media-only roots", () => {
+  assert.equal(summarizeThreadRoot("  **Launch**   plan  "), "Launch plan");
+  assert.equal(
+    summarizeThreadRoot("![diagram](https://example.com/diagram.png)"),
+    null,
+  );
+  assert.equal(
+    summarizeThreadRoot("See [the plan](https://example.com/plan) for details"),
+    "See the plan for details",
+  );
+  assert.match(summarizeThreadRoot("word ".repeat(30)) ?? "", /…$/);
+});