Merge dev: one-step /mumbl join + Slack teamspace fixes

Author: lladawn

scripts/slack-join-smoke.mjs

@@ -0,0 +1,71 @@
+import { createClient } from "@supabase/supabase-js";
+import { readFileSync } from "node:fs";
+
+// Load env from .env.local (same file db:link:staging uses).
+for (const line of readFileSync(new URL("../.env.local", import.meta.url), "utf8").split("\n")) {
+  const match = line.match(/^\s*([A-Z0-9_]+)\s*=\s*(.*)\s*$/);
+  if (match && !process.env[match[1]]) process.env[match[1]] = match[2].replace(/^["']|["']$/g, "");
+}
+
+const url = process.env.NEXT_PUBLIC_SUPABASE_URL;
+const key = process.env.SUPABASE_SERVICE_ROLE_KEY;
+if (!url || !key) throw new Error("missing NEXT_PUBLIC_SUPABASE_URL / SUPABASE_SERVICE_ROLE_KEY in .env.local");
+
+const supabase = createClient(url, key, { auth: { persistSession: false } });
+
+const teamId = `T_SMOKE_${crypto.randomUUID().slice(0, 8)}`;
+const slackUserId = `U_SMOKE_${crypto.randomUUID().slice(0, 8)}`;
+
+function assert(cond, msg) {
+  if (!cond) throw new Error(`ASSERT FAILED: ${msg}`);
+  console.log(`  ✓ ${msg}`);
+}
+
+// Reference a real space without creating one.
+const { data: space, error: spaceErr } = await supabase.from("spaces").select("id,slug").limit(1).single();
+if (spaceErr || !space) throw new Error("no spaces in DB to reference for the smoke test");
+console.log(`using space ${space.slug} (${space.id})\n`);
+
+let pinId;
+try {
+  // 1) A newcomer joins: pin with mumbl_user_id = null (the migration enables this).
+  const { data: pin, error: pinErr } = await supabase
+    .from("slack_pinned_spaces")
+    .insert({ mumbl_user_id: null, slack_team_id: teamId, slack_user_id: slackUserId, space_id: space.id })
+    .select("id,mumbl_user_id")
+    .single();
+  assert(!pinErr, `null-mumbl_user_id pin insert succeeds${pinErr ? ` — ${pinErr.message}` : ""}`);
+  assert(pin?.mumbl_user_id === null, "stored mumbl_user_id is null");
+  pinId = pin.id;
+
+  // 2) App Home / manage list keys on Slack identity — must find it without a connection.
+  const { data: listed } = await supabase
+    .from("slack_pinned_spaces")
+    .select("id,space_id")
+    .eq("slack_team_id", teamId)
+    .eq("slack_user_id", slackUserId);
+  assert(listed?.some((row) => row.id === pinId), "pin is listed by (slack_team_id, slack_user_id)");
+
+  // 3) Backfill on connect: a fake but valid-shaped uuid; use a real auth user so the FK holds.
+  const { data: authUser } = await supabase.from("slack_connections").select("mumbl_user_id").limit(1).maybeSingle();
+  if (authUser?.mumbl_user_id) {
+    const { error: backfillErr } = await supabase
+      .from("slack_pinned_spaces")
+      .update({ mumbl_user_id: authUser.mumbl_user_id })
+      .eq("slack_team_id", teamId)
+      .eq("slack_user_id", slackUserId)
+      .is("mumbl_user_id", null);
+    assert(!backfillErr, `backfill update sets mumbl_user_id${backfillErr ? ` — ${backfillErr.message}` : ""}`);
+    const { data: after } = await supabase.from("slack_pinned_spaces").select("mumbl_user_id").eq("id", pinId).single();
+    assert(after?.mumbl_user_id === authUser.mumbl_user_id, "pin now attributed to the connected mumbl user");
+  } else {
+    console.log("  ~ skipped backfill check (no existing slack_connections row to borrow a user id from)");
+  }
+
+  console.log("\nSMOKE PASS ✅");
+} finally {
+  if (pinId) {
+    await supabase.from("slack_pinned_spaces").delete().eq("id", pinId);
+    console.log("cleaned up smoke pin");
+  }
+}

src/server/slack.js

@@ -322,7 +322,21 @@ export async function createSlackStartedSpace({ teamId, slackUserId, name }) {
   }
 
   const handoff = await createCreatorHandoff({ spaceId: insertedSpace.id, creatorToken, accessToken });
-  const teamReadsSetup = await createTeamReadsSetup({ spaceId: insertedSpace.id });
+
+  // The room already exists at this point. If building the optional team-reads
+  // install link fails (e.g. missing Slack OAuth env), don't fail the whole
+  // creation — the user already has a working room. Just omit the button.
+  let teamReadsUrl = null;
+  try {
+    const teamReadsSetup = await createTeamReadsSetup({ spaceId: insertedSpace.id });
+    teamReadsUrl = slackTeamReadsInstallUrl(teamReadsSetup);
+  } catch (error) {
+    console.error("Slack team reads setup link failed after room creation", {
+      spaceId: insertedSpace.id,
+      message: error.message,
+    });
+  }
+
   return {
     space: insertedSpace,
     creatorToken,
@@ -331,7 +345,7 @@ export async function createSlackStartedSpace({ teamId, slackUserId, name }) {
     pinned: Boolean(connection),
     openUrl: slackSpaceHandoffUrl(handoff),
     roomUrl: slackRoomReadsUrl(insertedSpace, accessToken),
-    teamReadsUrl: slackTeamReadsInstallUrl(teamReadsSetup),
+    teamReadsUrl,
   };
 }
 
@@ -805,6 +819,17 @@ async function findSlackConnectionForAutoPin({ teamId, slackUserId }) {
   }
 }
 
+// Resolve a connection for joining/pinning a room. If the Slack user already
+// has (or can be matched to) a mumbl account, use that real connection so the
+// pin is attributed to it. Otherwise synthesize a Slack-identity-only stand-in:
+// pins are keyed on (slack_team_id, slack_user_id), so this is enough to pin and
+// invite in one step. `mumbl_user_id` stays null and backfills on connect.
+async function resolveSlackConnectionForJoin({ teamId, slackUserId }) {
+  const connection = await findSlackConnectionForAutoPin({ teamId, slackUserId });
+  if (connection) return connection;
+  return { slack_team_id: teamId, slack_user_id: slackUserId, mumbl_user_id: null };
+}
+
 export async function connectSlackUser({ teamId, slackUserId, mumblUserId }) {
   const supabase = getSupabaseAdmin();
   const sessionTokenHash = hashToken(`slack:${teamId}:${slackUserId}`);
@@ -824,9 +849,24 @@ export async function connectSlackUser({ teamId, slackUserId, mumblUserId }) {
     .single();
   if (error) throw error;
   await reconcileSlackStartedSpacesForConnection(data);
+  await backfillPinnedSpacesUserId(data);
   return data;
 }
 
+// When a Slack user connects their mumbl account, attribute any rooms they
+// joined earlier (pinned with a null mumbl_user_id) to that account.
+async function backfillPinnedSpacesUserId(connection) {
+  if (!connection?.mumbl_user_id || !connection.slack_team_id || !connection.slack_user_id) return;
+  const supabase = getSupabaseAdmin();
+  const { error } = await supabase
+    .from("slack_pinned_spaces")
+    .update({ mumbl_user_id: connection.mumbl_user_id })
+    .eq("slack_team_id", connection.slack_team_id)
+    .eq("slack_user_id", connection.slack_user_id)
+    .is("mumbl_user_id", null);
+  if (error) throw error;
+}
+
 export async function saveSlackDump({ connection, content, sourceMeta = {} }) {
   const supabase = getSupabaseAdmin();
   const cleanedContent = cleanString(content, 4000);
@@ -1001,7 +1041,7 @@ export async function updateSlackFieldNoteDraft({ teamId, slackUserId, fieldNote
 }
 
 export async function pinSlackSpaceBySlug({ teamId, slackUserId, slug }) {
-  const connection = await findOrCreateSlackConnectionByEmail({ teamId, slackUserId });
+  const connection = await resolveSlackConnectionForJoin({ teamId, slackUserId });
   const space = await findSpaceForSlackPin(slug);
   const pin = await pinSlackSpace({ connection, spaceId: space.id });
   const channelJoin = await inviteSlackUserToSpaceChannel({ teamId, slackUserId, spaceId: space.id });
@@ -1592,7 +1632,7 @@ export function slackRoomCreatedPayload({ space, openUrl, roomUrl, teamReadsUrl,
     blocks: [
       section(`*${escapeSlackText(space.name)} is ready.*\n${status}`),
       actions([
-        { text: "create team reads channel", url: teamReadsUrl, style: "primary" },
+        ...(teamReadsUrl ? [{ text: "create team reads channel", url: teamReadsUrl, style: "primary" }] : []),
         { text: creatorLinked ? "open team reads" : "claim room", url: openUrl },
         { text: "share with team", actionId: "share_room_invite", value: JSON.stringify({ roomUrl, spaceName: space.name }) },
       ]),
@@ -1617,7 +1657,7 @@ export function slackRoomCreatedModalView({ space, openUrl, roomUrl, teamReadsUr
           : `*${escapeSlackText(space.name)} is ready.*\nConnect once to claim creator access in Mumbl.`,
       ),
       actions([
-        { text: "create team reads channel", url: teamReadsUrl, style: "primary" },
+        ...(teamReadsUrl ? [{ text: "create team reads channel", url: teamReadsUrl, style: "primary" }] : []),
         { text: creatorLinked ? "open team reads" : "claim room", url: openUrl },
         { text: "share with team", actionId: "share_room_invite", value: JSON.stringify({ roomUrl, spaceName: space.name }) },
       ]),
@@ -1633,7 +1673,7 @@ export function slackRoomCreatedModalView({ space, openUrl, roomUrl, teamReadsUr
 }
 
 export function slackShareRoomInviteModalView({ roomUrl, spaceName }) {
-  const inviteMessage = `hey team — just set up a mumbl room for ${spaceName || "us"}.\nwrite private work thoughts, publish as team reads when ready.\n\nto join, run this in Slack:\n${slackJoinCommand(roomUrl)}`;
+  const inviteMessage = `📓 hey team — I set up a mumbl room for ${spaceName || "us"}.\n\nmumbl is where we keep the half-formed work thoughts privately, then shape the good ones into team reads when they're ready. ✍️\n\n👉 to join, copy this and run it in Slack:\n${slackJoinCommand(roomUrl)}\n\nyou'll land in our reads channel right away and the room pins to your mumbl App Home. ✨`;
   return {
     type: "modal",
     callback_id: "share_room_invite",
@@ -1963,7 +2003,7 @@ async function slackApi(method, token, body) {
 }
 
 function channelNameForSpace(space) {
-  return `mumbl-${slugify(space?.slug || space?.name || "team-reads")}`.slice(0, 80);
+  return `${slugify(space?.slug || space?.name || "team-reads")}`.slice(0, 80);
 }
 
 function teamReadMessage({ space, post, channel, roomAccessToken = "" }) {
@@ -1987,12 +2027,13 @@ async function slackAppHomeBlocks({ teamId, slackUserId }) {
   const { appUrl } = getServerEnv();
   const connection = await findSlackConnection({ teamId, slackUserId });
   const { patternGraphEnabled } = getServerEnv();
-  const [pinnedSpaces, pendingPattern] = connection
-    ? await Promise.all([
-        listSlackPinnedSpaces(connection),
-        patternGraphEnabled ? findPendingPattern(connection.mumbl_user_id) : null,
-      ])
-    : [[], null];
+  // Pins are keyed on Slack identity, so list them even before the user has a
+  // linked mumbl account — a teammate who just ran `/mumbl join` should see the
+  // room here without connecting first.
+  const [pinnedSpaces, pendingPattern] = await Promise.all([
+    listSlackPinnedSpaces(connection || { slack_team_id: teamId, slack_user_id: slackUserId }),
+    connection && patternGraphEnabled ? findPendingPattern(connection.mumbl_user_id) : null,
+  ]);
   const topPinnedSpaces = pinnedSpaces.slice(0, 5);
   const pinnedList = topPinnedSpaces
     .map((pin) => {
@@ -2313,6 +2354,25 @@ async function slackPinnedSpacesModal({ pinnedSpaces, notice = "" }) {
       { text: "open team reads", url: openReadsUrl },
       { text: "publish a draft", actionId: "review_field_note_drafts" },
     ];
+
+    // Offer a one-step "create reads channel" link for spaces that don't have
+    // one yet. Building the install link is optional — skip it if it fails.
+    if (!channel?.slack_channel_name && space.id) {
+      try {
+        const teamReadsSetup = await createTeamReadsSetup({ spaceId: space.id });
+        rowActions.push({
+          text: "create reads channel",
+          url: slackTeamReadsInstallUrl(teamReadsSetup),
+          style: "primary",
+        });
+      } catch (error) {
+        console.error("Slack team reads setup link failed in manage teamspaces", {
+          spaceId: space.id,
+          message: error.message,
+        });
+      }
+    }
+
     rowActions.push({ text: "unpin", actionId: "unpin_pinned_space_start", value: pin.id, style: "danger" });
 
     blocks.push(

supabase/migrations/0002_nullable_pinned_space_user.sql

@@ -0,0 +1,7 @@
+-- Allow pinning a Slack space before the Slack user has a linked mumbl account.
+-- Pins are keyed and read entirely by (slack_team_id, slack_user_id); the
+-- mumbl_user_id column is denormalized and backfilled when the user connects.
+-- Dropping NOT NULL lets `/mumbl join` pin a room in one step, with no Google
+-- auth, for teammates who have never visited mumbl.
+alter table slack_pinned_spaces
+  alter column mumbl_user_id drop not null;