fix: pass threadId to reply functions for proper threading

The reply functions (replyToThread, replyAllToThread, forwardThread) were
receiving threadId but not using it. This caused syncThreadId to fail when
threadPane.threadId wasn't already set, leading to "Failed to create reply"
errors and fallback to draft mode.

Changes:
- Add setThreadForReply() to explicitly set thread context
- Update openComposeWithCommand() to accept optional threadId
- Pass threadId from reply.ts to openReplyCompose/openReplyAllCompose/openForwardCompose

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: edwinhu

src/reply.ts

@@ -46,18 +46,18 @@ async function completeDraft(
  * threading (threadId, inReplyTo, references), recipients, and subject.
  *
  * @param conn - The Superhuman connection
- * @param _threadId - The thread ID (must be the currently open thread; unused as native command uses current thread)
+ * @param threadId - The thread ID to reply to
  * @param body - The reply body text
  * @param send - If true, send immediately; if false, save as draft
  * @returns Result with success status and optional draft ID
  */
 export async function replyToThread(
   conn: SuperhumanConnection,
-  _threadId: string,
+  threadId: string,
   body: string,
   send: boolean = false
 ): Promise<ReplyResult> {
-  const draftKey = await openReplyCompose(conn);
+  const draftKey = await openReplyCompose(conn, threadId);
   if (!draftKey) {
     return { success: false };
   }
@@ -78,18 +78,18 @@ export async function replyToThread(
  * and subject automatically.
  *
  * @param conn - The Superhuman connection
- * @param _threadId - The thread ID (must be the currently open thread; unused as native command uses current thread)
+ * @param threadId - The thread ID to reply to
  * @param body - The reply body text
  * @param send - If true, send immediately; if false, save as draft
  * @returns Result with success status and optional draft ID
  */
 export async function replyAllToThread(
   conn: SuperhumanConnection,
-  _threadId: string,
+  threadId: string,
   body: string,
   send: boolean = false
 ): Promise<ReplyResult> {
-  const draftKey = await openReplyAllCompose(conn);
+  const draftKey = await openReplyAllCompose(conn, threadId);
   if (!draftKey) {
     return { success: false };
   }
@@ -109,20 +109,20 @@ export async function replyAllToThread(
  * the forwarded message content, subject, and formatting.
  *
  * @param conn - The Superhuman connection
- * @param _threadId - The thread ID (must be the currently open thread; unused as native command uses current thread)
+ * @param threadId - The thread ID to forward
  * @param toEmail - The email address to forward to
  * @param body - The message body to include before the forwarded content
  * @param send - If true, send immediately; if false, save as draft
  * @returns Result with success status and optional draft ID
  */
 export async function forwardThread(
   conn: SuperhumanConnection,
-  _threadId: string,
+  threadId: string,
   toEmail: string,
   body: string,
   send: boolean = false
 ): Promise<ReplyResult> {
-  const draftKey = await openForwardCompose(conn);
+  const draftKey = await openForwardCompose(conn, threadId);
   if (!draftKey) {
     return { success: false };
   }

src/superhuman-api.ts

@@ -455,10 +455,18 @@ async function closeExistingCompose(conn: SuperhumanConnection): Promise<void> {
  */
 async function openComposeWithCommand(
   conn: SuperhumanConnection,
-  commandId: string
+  commandId: string,
+  threadId?: string
 ): Promise<string | null> {
   await closeExistingCompose(conn);
-  await syncThreadId(conn);
+
+  // If a specific threadId is provided, set it before invoking the command
+  if (threadId) {
+    await setThreadForReply(conn, threadId);
+    await new Promise((r) => setTimeout(r, 300)); // Give UI time to update
+  } else {
+    await syncThreadId(conn);
+  }
 
   const invoked = await invokeCommand(conn, commandId);
   if (!invoked) {
@@ -469,6 +477,40 @@ async function openComposeWithCommand(
   return getDraftKey(conn);
 }
 
+/**
+ * Set a specific thread ID in the ViewState for reply operations
+ *
+ * This sets both threadPane.threadId and threadListView.threadId to ensure
+ * the reply commands work correctly regardless of what's currently visible.
+ */
+export async function setThreadForReply(conn: SuperhumanConnection, threadId: string): Promise<boolean> {
+  const { Runtime } = conn;
+
+  const result = await Runtime.evaluate({
+    expression: `
+      (() => {
+        try {
+          const tree = window.ViewState?.tree;
+          if (!tree?.set) return false;
+
+          const targetThreadId = ${JSON.stringify(threadId)};
+
+          // Set both threadPane and threadListView to the target thread
+          tree.set(['threadPane', 'threadId'], targetThreadId);
+          tree.set(['threadListView', 'threadId'], targetThreadId);
+
+          return true;
+        } catch (e) {
+          return false;
+        }
+      })()
+    `,
+    returnByValue: true,
+  });
+
+  return result.result.value === true;
+}
+
 /**
  * Sync threadListView.threadId with threadPane.threadId
  *
@@ -507,27 +549,36 @@ export async function syncThreadId(conn: SuperhumanConnection): Promise<boolean>
  *
  * This uses the REPLY_ALL_POP_OUT command which properly sets up threading,
  * recipients, and subject automatically.
+ *
+ * @param conn - The Superhuman connection
+ * @param threadId - Optional thread ID to reply to (if not provided, uses current thread)
  */
-export async function openReplyAllCompose(conn: SuperhumanConnection): Promise<string | null> {
-  return openComposeWithCommand(conn, "REPLY_ALL_POP_OUT");
+export async function openReplyAllCompose(conn: SuperhumanConnection, threadId?: string): Promise<string | null> {
+  return openComposeWithCommand(conn, "REPLY_ALL_POP_OUT", threadId);
 }
 
 /**
  * Open a reply compose using Superhuman's native command.
  *
  * This uses the REPLY_POP_OUT command which properly sets up threading,
  * recipient (original sender only), and subject automatically.
+ *
+ * @param conn - The Superhuman connection
+ * @param threadId - Optional thread ID to reply to (if not provided, uses current thread)
  */
-export async function openReplyCompose(conn: SuperhumanConnection): Promise<string | null> {
-  return openComposeWithCommand(conn, "REPLY_POP_OUT");
+export async function openReplyCompose(conn: SuperhumanConnection, threadId?: string): Promise<string | null> {
+  return openComposeWithCommand(conn, "REPLY_POP_OUT", threadId);
 }
 
 /**
  * Open a forward compose using Superhuman's native command.
  *
  * This uses the FORWARD_POP_OUT command which properly sets up the
  * forwarded message content and subject automatically.
+ *
+ * @param conn - The Superhuman connection
+ * @param threadId - Optional thread ID to forward (if not provided, uses current thread)
  */
-export async function openForwardCompose(conn: SuperhumanConnection): Promise<string | null> {
-  return openComposeWithCommand(conn, "FORWARD_POP_OUT");
+export async function openForwardCompose(conn: SuperhumanConnection, threadId?: string): Promise<string | null> {
+  return openComposeWithCommand(conn, "FORWARD_POP_OUT", threadId);
 }