Add Slack draft review modal

Author: lladawn

README.md

@@ -87,7 +87,7 @@ Until those variables exist, API routes return a setup `503`.
 
 ## Slack Beta Setup
 
-The Slack app is a free beta entry point for private dumps. It supports `/mumbl [text]`, `/mumbl room [team name]`, a `save_to_mumbl` message shortcut, App Home private dumping, and App Home field-note drafting from recent private dumps. It does not read channel history.
+The Slack app is a free beta entry point for private dumps. It supports `/mumbl [text]`, `/mumbl room [team name]`, a `save_to_mumbl` message shortcut, App Home private dumping, and App Home field-note drafting/review from recent private dumps. It does not read channel history.
 
 In Slack app settings:
 

app/api/slack/interactions/route.js

@@ -8,6 +8,7 @@ import {
   ephemeralText,
   findMumblUserByEmail,
   findSlackConnection,
+  getSlackFieldNoteDraft,
   getSlackUserEmail,
   parseVerifiedSlackForm,
   postSlackResponse,
@@ -17,14 +18,18 @@ import {
   slackConnectUrl,
   slackDumpConnectModalView,
   slackDumpSavedModalView,
+  slackFieldNoteEditModalView,
   slackFieldNoteDraftingModalView,
   slackFieldNoteDraftReadyModalView,
   slackFieldNoteDraftErrorModalView,
+  slackFieldNoteSavedModalView,
   slackSavedDumpPayload,
   openSlackDumpModal,
   openSlackFieldNoteDraftModal,
+  openSlackFieldNoteReviewModal,
   openSlackRoomModal,
   updateSlackView,
+  updateSlackFieldNoteDraft,
 } from "../../../../src/server/slack";
 import { cleanString } from "../../../../src/server/validation";
 
@@ -57,6 +62,13 @@ export async function POST(request) {
             triggerId: cleanString(payload.trigger_id, 200),
           });
         }
+        if (actionId === "review_field_note_drafts") {
+          await openSlackFieldNoteReviewModal({
+            teamId: slackTeamId(payload),
+            slackUserId: cleanString(payload.user?.id, 80),
+            triggerId: cleanString(payload.trigger_id, 200),
+          });
+        }
       } catch (error) {
         console.error("Slack App Home action failed", error);
       }
@@ -116,6 +128,58 @@ export async function POST(request) {
       return ok({ response_action: "update", view: slackFieldNoteDraftingModalView() });
     }
 
+    if (payload.type === "view_submission" && payload.view?.callback_id === "review_field_note_drafts") {
+      const teamId = slackTeamId(payload);
+      const slackUserId = cleanString(payload.user?.id, 80);
+      const fieldNoteId = cleanString(payload.view?.state?.values?.field_note_id?.value?.selected_option?.value, 64);
+      if (!fieldNoteId) {
+        return ok({
+          response_action: "errors",
+          errors: { field_note_id: "choose a draft." },
+        });
+      }
+
+      try {
+        const fieldNote = await getSlackFieldNoteDraft({ teamId, slackUserId, fieldNoteId });
+        return ok({ response_action: "update", view: slackFieldNoteEditModalView(fieldNote) });
+      } catch (error) {
+        return ok({
+          response_action: "errors",
+          errors: { field_note_id: error.message || "couldn't open that draft." },
+        });
+      }
+    }
+
+    if (payload.type === "view_submission" && payload.view?.callback_id === "edit_field_note_draft") {
+      const teamId = slackTeamId(payload);
+      const slackUserId = cleanString(payload.user?.id, 80);
+      const fieldNoteId = cleanString(payload.view?.private_metadata, 64);
+      const title = cleanString(payload.view?.state?.values?.field_note_title?.value?.value, 120);
+      const content = cleanString(payload.view?.state?.values?.field_note_content?.value?.value, 4000);
+      if (!title) {
+        return ok({
+          response_action: "errors",
+          errors: { field_note_title: "title the draft first." },
+        });
+      }
+      if (!content) {
+        return ok({
+          response_action: "errors",
+          errors: { field_note_content: "write the field note first." },
+        });
+      }
+
+      try {
+        const result = await updateSlackFieldNoteDraft({ teamId, slackUserId, fieldNoteId, title, content });
+        return ok({ response_action: "update", view: slackFieldNoteSavedModalView(result) });
+      } catch (error) {
+        return ok({
+          response_action: "errors",
+          errors: { field_note_content: error.message || "couldn't save that draft." },
+        });
+      }
+    }
+
     if (payload.type === "view_submission" && payload.view?.callback_id === "create_mumbl_room") {
       const teamId = slackTeamId(payload);
       const slackUserId = cleanString(payload.user?.id, 80);

docs/free-tier-compromises.md

@@ -76,7 +76,7 @@ Current compromise:
 - Slack is free during beta. There is no 30-day countdown, no credit card, and no usage gate.
 - The beta supports only explicit user actions: `/mumbl [text]` and the `save_to_mumbl` message shortcut.
 - `/mumbl room [team name]` can create a Mumbl room from Slack with an expiring creator handoff link. `/mumbl start [team name]` remains an alias.
-- App Home can create private dumps and draft a field note from selected recent private dumps. Drafting uses the existing field-note OpenAI daily limit, and publishing still requires review in Mumbl.
+- App Home can create private dumps, draft a field note from selected recent private dumps, and edit recent private drafts. Drafting uses the existing field-note OpenAI daily limit, and publishing still requires review in Mumbl.
 - The Slack app requests `commands`, `users:read`, and `users:read.email` only. It does not request channel history or message history scopes.
 - Team-read posting to Slack is optional per room. When a creator enables it, Mumbl asks for an optional `chat:write` and `groups:write` permission upgrade only so it can create one private channel and post published team reads.
 - Slack daily check-in reminders are deferred because a 15-minute scheduler does not fit the free-tier posture.

src/server/slack.js

@@ -452,6 +452,29 @@ export async function openSlackFieldNoteDraftModal({ teamId, slackUserId, trigge
   });
 }
 
+export async function openSlackFieldNoteReviewModal({ teamId, slackUserId, triggerId }) {
+  const installation = await getSlackInstallation(teamId);
+  const token = decryptSlackToken({
+    ciphertext: installation.bot_access_token_ciphertext,
+    iv: installation.bot_access_token_iv,
+    tag: installation.bot_access_token_tag,
+  });
+
+  let view;
+  try {
+    const connection = await findOrCreateSlackConnectionByEmail({ teamId, slackUserId });
+    const fieldNotes = await recentSlackFieldNoteDrafts(connection);
+    view = fieldNotes.length ? slackFieldNoteReviewModal({ fieldNotes }) : slackNoFieldNoteDraftsModal();
+  } catch (error) {
+    view = slackFieldNoteDraftUnavailableModal(error.message || "connect mumbl first.");
+  }
+
+  return slackApi("views.open", token, {
+    trigger_id: triggerId,
+    view,
+  });
+}
+
 export async function updateSlackView({ teamId, viewId, view }) {
   const installation = await getSlackInstallation(teamId);
   const token = decryptSlackToken({
@@ -615,6 +638,56 @@ export async function recentSlackPrivateDumps(connection) {
   return data || [];
 }
 
+export async function recentSlackFieldNoteDrafts(connection) {
+  const supabase = getSupabaseAdmin();
+  const { data, error } = await supabase
+    .from("field_notes")
+    .select("id, title, content, created_at, source_dump_ids")
+    .eq("user_id", connection.mumbl_user_id)
+    .eq("is_published", false)
+    .order("created_at", { ascending: false })
+    .limit(10);
+  if (error) throw error;
+  return data || [];
+}
+
+export async function getSlackFieldNoteDraft({ teamId, slackUserId, fieldNoteId }) {
+  const connection = await findOrCreateSlackConnectionByEmail({ teamId, slackUserId });
+  const supabase = getSupabaseAdmin();
+  const { data, error } = await supabase
+    .from("field_notes")
+    .select("id, title, content, created_at, source_dump_ids")
+    .eq("user_id", connection.mumbl_user_id)
+    .eq("is_published", false)
+    .eq("id", cleanString(fieldNoteId, 64))
+    .single();
+  if (error) throw error;
+  return data;
+}
+
+export async function updateSlackFieldNoteDraft({ teamId, slackUserId, fieldNoteId, title, content }) {
+  const connection = await findOrCreateSlackConnectionByEmail({ teamId, slackUserId });
+  const cleanedTitle = cleanString(title, 120);
+  const cleanedContent = cleanString(content, 4000);
+  if (!cleanedTitle) throw new Error("field note title is required.");
+  if (!cleanedContent) throw new Error("field note content is required.");
+
+  const supabase = getSupabaseAdmin();
+  const { data, error } = await supabase
+    .from("field_notes")
+    .update({ title: cleanedTitle, content: cleanedContent })
+    .eq("user_id", connection.mumbl_user_id)
+    .eq("is_published", false)
+    .eq("id", cleanString(fieldNoteId, 64))
+    .select("id, title")
+    .single();
+  if (error) throw error;
+  return {
+    fieldNote: data,
+    url: `${getServerEnv().appUrl}/dump?fieldNote=${encodeURIComponent(data.id)}`,
+  };
+}
+
 export async function createSlackFieldNoteDraft({ teamId, slackUserId, dumpIds }) {
   const cleanedDumpIds = Array.isArray(dumpIds) ? dumpIds.map((id) => cleanString(id, 64)).filter(Boolean) : [];
   if (!cleanedDumpIds.length) throw new Error("choose at least one dump.");
@@ -804,6 +877,70 @@ export function slackFieldNoteDraftReadyModalView({ fieldNote, url, visibilityRe
   };
 }
 
+export function slackFieldNoteEditModalView(fieldNote) {
+  const content = cleanString(fieldNote.content, 4000);
+  if (content.length > 3000) {
+    const { appUrl } = getServerEnv();
+    return {
+      type: "modal",
+      title: { type: "plain_text", text: "open in mumbl" },
+      close: { type: "plain_text", text: "done" },
+      blocks: [
+        section("*this draft is too long for Slack editing.*\nOpen it in Mumbl to keep the whole thing intact."),
+        actions([{ text: "open in mumbl", url: `${appUrl}/dump?fieldNote=${encodeURIComponent(fieldNote.id)}` }]),
+      ],
+    };
+  }
+
+  return {
+    type: "modal",
+    callback_id: "edit_field_note_draft",
+    private_metadata: fieldNote.id,
+    title: { type: "plain_text", text: "edit draft" },
+    submit: { type: "plain_text", text: "save" },
+    close: { type: "plain_text", text: "cancel" },
+    blocks: [
+      {
+        type: "input",
+        block_id: "field_note_title",
+        label: { type: "plain_text", text: "title" },
+        element: {
+          type: "plain_text_input",
+          action_id: "value",
+          initial_value: cleanString(fieldNote.title, 120) || "field note",
+          max_length: 120,
+        },
+      },
+      {
+        type: "input",
+        block_id: "field_note_content",
+        label: { type: "plain_text", text: "field note" },
+        element: {
+          type: "plain_text_input",
+          action_id: "value",
+          initial_value: content,
+          multiline: true,
+          max_length: 3000,
+        },
+      },
+      context("Saving keeps this private. Publish to team reads from Mumbl after one last review."),
+    ],
+  };
+}
+
+export function slackFieldNoteSavedModalView({ fieldNote, url }) {
+  return {
+    type: "modal",
+    title: { type: "plain_text", text: "draft saved" },
+    close: { type: "plain_text", text: "done" },
+    blocks: [
+      section(`*${escapeSlackText(fieldNote.title || "field note draft")}*`),
+      section("Saved privately. Open it in Mumbl when you are ready to publish to team reads."),
+      actions([{ text: "open in mumbl", url }]),
+    ],
+  };
+}
+
 export function slackFieldNoteDraftErrorModalView(message) {
   return {
     type: "modal",
@@ -944,6 +1081,8 @@ function slackAppHomeBlocks() {
     actions([{ text: "new private dump", actionId: "new_private_dump" }]),
     section("*draft a team read*\nChoose a few recent private dumps and Mumbl will turn them into a private field-note draft."),
     actions([{ text: "draft team read", actionId: "draft_team_read" }]),
+    section("*review drafts*\nEdit recent private field-note drafts before anything goes to the team."),
+    actions([{ text: "review drafts", actionId: "review_field_note_drafts" }]),
     section("*start a team space from Slack*\nType `/mumbl room platform team` to create the room without leaving Slack."),
     actions([{ text: "start a team room", actionId: "start_room_modal" }]),
     section("*team reads on Slack*\nAfter a room is created, use its `enable Slack team reads` button to create one private channel."),
@@ -1029,6 +1168,43 @@ function slackFieldNoteDraftModal({ dumps }) {
   };
 }
 
+function slackFieldNoteReviewModal({ fieldNotes }) {
+  return {
+    type: "modal",
+    callback_id: "review_field_note_drafts",
+    title: { type: "plain_text", text: "review drafts" },
+    submit: { type: "plain_text", text: "edit" },
+    close: { type: "plain_text", text: "cancel" },
+    blocks: [
+      {
+        type: "input",
+        block_id: "field_note_id",
+        label: { type: "plain_text", text: "draft" },
+        element: {
+          type: "static_select",
+          action_id: "value",
+          placeholder: { type: "plain_text", text: "choose a draft" },
+          options: fieldNotes.map((fieldNote) => fieldNoteOption(fieldNote)),
+        },
+      },
+      context("Drafts stay private here. Publishing still happens from Mumbl."),
+    ],
+  };
+}
+
+function slackNoFieldNoteDraftsModal() {
+  const { appUrl } = getServerEnv();
+  return {
+    type: "modal",
+    title: { type: "plain_text", text: "no drafts" },
+    close: { type: "plain_text", text: "done" },
+    blocks: [
+      section("*no private field-note drafts yet.*\nDraft one from recent dumps first."),
+      actions([{ text: "open your dump", url: `${appUrl}/dump` }]),
+    ],
+  };
+}
+
 function slackFieldNoteNoDumpsModal() {
   const { appUrl } = getServerEnv();
   return {
@@ -1067,6 +1243,18 @@ function dumpOption(dump) {
   };
 }
 
+function fieldNoteOption(fieldNote) {
+  const date = new Date(fieldNote.created_at);
+  return {
+    text: { type: "plain_text", text: truncatePlain(fieldNote.title || firstLine(fieldNote.content), 75) },
+    value: fieldNote.id,
+    description: {
+      type: "plain_text",
+      text: truncatePlain(date.toLocaleDateString("en-US", { month: "short", day: "numeric" }), 75),
+    },
+  };
+}
+
 function blockResponse({ text, blocks, replaceOriginal = false }) {
   return {
     response_type: "ephemeral",