Streamline Slack room creation and pinning

Author: lladawn

README.md

@@ -103,7 +103,7 @@ In Slack app settings:
 
 Set `SLACK_CLIENT_ID`, `SLACK_CLIENT_SECRET`, `SLACK_SIGNING_SECRET`, and `MUMBL_SLACK_TOKEN_ENCRYPTION_KEY` in the deployment environment. Install through `/api/slack/install`.
 
-`/mumbl room platform team` creates a Mumbl room from Slack and returns a one-time creator handoff link for opening the room in a browser. `/mumbl start platform team` remains an alias. Slack-created rooms are auto-pinned for the creator when Mumbl can match their Slack email to a Mumbl login. `/mumbl pin platform-team` explicitly adds a Mumbl room to that Slack user's publish list without tracking room membership. App Home can draft, review, edit, publish private field notes to pinned Mumbl spaces, and manage personal pinned spaces. Optional team-read Slack posting is creator-enabled per room. If a creator switches it on, Mumbl starts an optional Slack permission upgrade that asks for `chat:write`, `groups:write`, and `groups:read` so it can create one private channel, post published team reads there, and auto-pin that Mumbl room when a connected user joins the Mumbl-created Slack channel. It still does not request Slack history scopes.
+`/mumbl room platform team` creates a Mumbl room from Slack and returns a one-time creator handoff link for opening the room in a browser. `/mumbl start platform team` remains an alias. Slack-created rooms are auto-pinned for the creator when Mumbl can match their Slack email to a Mumbl login. `/mumbl pin platform-team` explicitly adds a Mumbl room to that Slack user's publish list without tracking room membership, and best-effort invites them into the room's Mumbl-created Slack reads channel when one exists. App Home can draft, review, edit, publish private field notes to pinned Mumbl spaces, and manage personal pinned spaces. Optional team-read Slack posting is creator-enabled per room. If a creator switches it on, Mumbl starts an optional Slack permission upgrade that asks for `chat:write`, `groups:write`, and `groups:read` so it can create one private channel, post published team reads there, and auto-pin that Mumbl room when a connected user joins the Mumbl-created Slack channel. It still does not request Slack history scopes.
 
 Slack reminders are intentionally not part of the beta because frequent scheduling does not fit the current free-tier posture.
 

app/api/slack/commands/route.js

@@ -12,6 +12,7 @@ import {
   parseVerifiedSlackForm,
   pinSlackSpaceBySlug,
   postSlackResponse,
+  publishSlackAppHome,
   saveSlackDump,
   slackConnectPayload,
   slackConnectUrl,
@@ -55,6 +56,13 @@ export async function POST(request) {
               ? await pinSpaceFromSlack({ teamId, slackUserId, slug: pinSlug })
             : await saveOrConnect({ teamId, slackUserId, content: text, sourceMeta: { trigger: "slash_command" } });
         await postSlackResponse(responseUrl, result);
+        if (roomName !== null || pinSlug !== null) {
+          try {
+            await publishSlackAppHome({ teamId, slackUserId });
+          } catch (error) {
+            console.error("Slack App Home refresh after command failed", { message: error.message, slackError: error.slack?.error });
+          }
+        }
       } catch (error) {
         await postSlackResponse(responseUrl, ephemeralText(error.message || "couldn't finish that Mumbl action yet."));
       }
@@ -88,8 +96,11 @@ async function startRoomFromSlack({ teamId, slackUserId, name }) {
 }
 
 async function pinSpaceFromSlack({ teamId, slackUserId, slug }) {
-  const { space } = await pinSlackSpaceBySlug({ teamId, slackUserId, slug });
-  return ephemeralText(`${space.name} is pinned for team reads.`);
+  const { space, channelJoin } = await pinSlackSpaceBySlug({ teamId, slackUserId, slug });
+  const channelText = channelJoin?.joined
+    ? ` You're also in the ${channelJoin.channelName ? `#${channelJoin.channelName}` : "Slack reads"} channel.`
+    : "";
+  return ephemeralText(`${space.name} is pinned for team reads.${channelText}`);
 }
 
 async function saveOrConnect({ teamId, slackUserId, content, sourceMeta }) {

app/api/slack/interactions/route.js

@@ -495,6 +495,13 @@ export async function POST(request) {
 
       try {
         const view = await createSlackStartedSpaceModalView({ teamId, slackUserId, name: roomName });
+        after(async () => {
+          try {
+            await publishSlackAppHome({ teamId, slackUserId });
+          } catch (error) {
+            console.error("Slack App Home refresh after room creation failed", { message: error.message, slackError: error.slack?.error });
+          }
+        });
         return ok({ response_action: "update", view });
       } catch (error) {
         return ok({

src/server/slack.js

@@ -269,6 +269,8 @@ export async function createSlackStartedSpace({ teamId, slackUserId, name }) {
   return {
     space: insertedSpace,
     creatorToken,
+    creatorLinked: Boolean(connection?.mumbl_user_id),
+    pinned: Boolean(connection),
     openUrl: slackSpaceHandoffUrl(handoff),
     roomUrl: `${getServerEnv().appUrl}/r/${insertedSpace.slug}`,
     teamReadsUrl: slackTeamReadsInstallUrl(teamReadsSetup),
@@ -786,7 +788,8 @@ export async function pinSlackSpaceBySlug({ teamId, slackUserId, slug }) {
   const connection = await findOrCreateSlackConnectionByEmail({ teamId, slackUserId });
   const space = await findSpaceForSlackPin(slug);
   await pinSlackSpace({ connection, spaceId: space.id });
-  return { space };
+  const channelJoin = await inviteSlackUserToSpaceChannel({ teamId, slackUserId, spaceId: space.id });
+  return { space, channelJoin };
 }
 
 export async function pinSlackSpaceForMumblUser({ mumblUserId, spaceId }) {
@@ -802,6 +805,11 @@ export async function pinSlackSpaceForMumblUser({ mumblUserId, spaceId }) {
   if (error) throw error;
   if (!connection) throw new Error("connect Slack once before pinning this room.");
   await pinSlackSpace({ connection, spaceId });
+  await inviteSlackUserToSpaceChannel({
+    teamId: connection.slack_team_id,
+    slackUserId: connection.slack_user_id,
+    spaceId,
+  });
   return connection;
 }
 
@@ -1012,6 +1020,42 @@ async function getPinnedSpace({ connection, spaceId }) {
   return data;
 }
 
+async function inviteSlackUserToSpaceChannel({ teamId, slackUserId, spaceId }) {
+  const supabase = getSupabaseAdmin();
+  const { data: channel, error } = await supabase
+    .from("slack_space_channels")
+    .select("slack_channel_id, slack_channel_name, posting_enabled")
+    .eq("slack_team_id", cleanString(teamId, 80))
+    .eq("space_id", cleanString(spaceId, 64))
+    .maybeSingle();
+  if (error) throw error;
+  if (!channel?.slack_channel_id) return { joined: false, reason: "no_slack_channel" };
+
+  try {
+    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,
+    });
+    await slackApi("conversations.invite", token, {
+      channel: channel.slack_channel_id,
+      users: cleanString(slackUserId, 80),
+    });
+    return { joined: true, channelName: channel.slack_channel_name };
+  } catch (error) {
+    if (error.slack?.error === "already_in_channel") {
+      return { joined: true, alreadyInChannel: true, channelName: channel.slack_channel_name };
+    }
+    console.error("Slack channel invite after pin failed", {
+      message: error.message,
+      slackError: error.slack?.error,
+      spaceId,
+    });
+    return { joined: false, reason: error.slack?.error || "invite_failed", channelName: channel.slack_channel_name };
+  }
+}
+
 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.");
@@ -1118,34 +1162,47 @@ export function slackRoomNeedsNamePayload() {
   });
 }
 
-export function slackRoomCreatedPayload({ space, openUrl, roomUrl, teamReadsUrl }) {
+export function slackRoomCreatedPayload({ space, openUrl, roomUrl, teamReadsUrl, creatorLinked, pinned }) {
+  const status = creatorLinked
+    ? "linked to your Mumbl login and pinned in Slack."
+    : "created from Slack. Connect once to claim creator access in Mumbl.";
   return blockResponse({
     text: `created a mumbl room for ${space.name}.`,
     blocks: [
-      section(`*created a mumbl room for ${escapeSlackText(space.name)}.*\nprivate dumps stay private. team reads only post to Slack if you enable them.`),
+      section(`*${escapeSlackText(space.name)} is ready.*\n${status}`),
       actions([
-        { text: "open room", url: openUrl },
-        { text: "open invite link", url: roomUrl },
-        { text: "enable Slack team reads", url: teamReadsUrl },
+        { text: "create Slack reads channel", url: teamReadsUrl, style: "primary" },
+        { text: creatorLinked ? "open room" : "claim room", url: openUrl },
       ]),
-      context(`invite link: <${roomUrl}|${roomUrl}>`),
+      context(
+        pinned
+          ? `Pinned for publishing. Invite link: <${roomUrl}|${roomUrl}>`
+          : `Use /mumbl pin ${space.slug} after connecting Mumbl. Invite link: <${roomUrl}|${roomUrl}>`,
+      ),
     ],
   });
 }
 
-export function slackRoomCreatedModalView({ space, openUrl, roomUrl, teamReadsUrl }) {
+export function slackRoomCreatedModalView({ space, openUrl, roomUrl, teamReadsUrl, creatorLinked, pinned }) {
   return {
     type: "modal",
     title: { type: "plain_text", text: "room created" },
     close: { type: "plain_text", text: "done" },
     blocks: [
-      section(`*created a mumbl room for ${escapeSlackText(space.name)}.*\nIt is ready for team reads. Open it once to save creator access in this browser.`),
+      section(
+        creatorLinked
+          ? `*${escapeSlackText(space.name)} is ready.*\nIt is linked to your Mumbl login and pinned in Slack.`
+          : `*${escapeSlackText(space.name)} is ready.*\nConnect once to claim creator access in Mumbl.`,
+      ),
       actions([
-        { text: "open room", url: openUrl },
-        { text: "open invite link", url: roomUrl },
-        { text: "enable Slack team reads", url: teamReadsUrl },
+        { text: "create Slack reads channel", url: teamReadsUrl, style: "primary" },
+        { text: creatorLinked ? "open room" : "claim room", url: openUrl },
       ]),
-      context("Publishing to Mumbl team reads works now. Posting those reads into a Slack channel stays optional."),
+      context(
+        pinned
+          ? "Pinned for publishing. Slack reads channel is optional and only mirrors published team reads."
+          : "After connecting, Mumbl can pin this space for publishing from Slack.",
+      ),
     ],
   };
 }