Route personal Slack notifications to DM, channel for public accountability

Personal reminders (10-min/5-min session warnings, pre-reservation, late
check-in) now go directly to the user via Slack DM so the channel is not
flooded with repeated @mentions. Grace period exceeded, overdue, no-show,
and suspension notifications stay in the channel since they affect shared
resources and warrant community visibility.

"Move your car" admin requests now DM the owner privately while posting a
brief, mention-free note to the channel for transparency.

New functions: sendSlackDM (conversations.open + chat.postMessage),
notifyUser (DM-first with email fallback). Bot token now requires im:write
scope in addition to chat:write and users:read.email.

Author: nmayalais

web/.env.example

@@ -20,5 +20,7 @@ CRON_SECRET=generate-with-openssl-rand-base64-32
 NEXT_PUBLIC_POSTHOG_KEY=
 
 # Slack (optional)
+# Bot token requires scopes: chat:write, users:read.email, im:write
+# im:write is needed to send direct messages to users
 SLACK_BOT_TOKEN=
 SLACK_WEBHOOK_URL=

web/src/actions/admin.ts

@@ -8,6 +8,7 @@ import { assertAdmin } from '@/lib/auth-helpers';
 import { isComplete } from '@/lib/utils';
 import {
   notifyChannel,
+  notifyUser,
   buildMoveCarMessage,
   getSlackChannelMention,
   type NotifyChannelConfig,
@@ -193,15 +194,21 @@ export async function notifyOwner(
   const appName = configMap.app_name || 'EV Charging';
 
   const message = buildMoveCarMessage(appName, chargerName, channelMention);
+  const channelMessage = `${appName}: A request was sent to move a car at ${chargerName}.`;
 
   const notifyConfig = buildNotifyConfig(configMap);
-  const sent = await notifyChannel(message, notifyConfig, session.userId);
+
+  // DM the owner directly so only they get pinged
+  const dmSent = await notifyUser(message, notifyConfig, session.userId);
+
+  // Post a brief, mention-free note to the channel so everyone knows action was taken
+  await notifyChannel(channelMessage, notifyConfig);
 
   const board = await getBoardData(auth);
 
   return {
-    success: sent,
-    message: sent
+    success: dmSent,
+    message: dmSent
       ? 'Notification sent to the session owner.'
       : 'Unable to send notification. Please contact the owner directly.',
     board,

web/src/lib/__tests__/admin.test.ts

@@ -38,6 +38,7 @@ vi.mock('@/actions/board', () => ({
 // Mock notifications
 vi.mock('@/lib/notifications', () => ({
   notifyChannel: vi.fn(),
+  notifyUser: vi.fn(),
   buildMoveCarMessage: vi.fn(
     (appName: string, chargerName: string, channelMention: string) =>
       `${appName}: Someone is waiting for ${chargerName}. Please move your car and post any delays in ${channelMention}.`,
@@ -48,7 +49,7 @@ vi.mock('@/lib/notifications', () => ({
 import { resetCharger, forceEndSession, notifyOwner } from '@/actions/admin';
 import { getConfig } from '@/lib/config';
 import { getBoardData } from '@/actions/board';
-import { notifyChannel } from '@/lib/notifications';
+import { notifyChannel, notifyUser } from '@/lib/notifications';
 import type { Auth } from '@/types';
 
 // ---------------------------------------------------------------------------
@@ -251,25 +252,33 @@ describe('notifyOwner', () => {
     const session = makeSession({ userId: 'driver@example.com' });
 
     setupDbMocks([[charger], [session]]);
+    (notifyUser as ReturnType<typeof vi.fn>).mockResolvedValue(true);
     (notifyChannel as ReturnType<typeof vi.fn>).mockResolvedValue(true);
 
     const result = await notifyOwner('charger-1', nonAdminAuth);
 
     expect(result.success).toBe(true);
     expect(result.message).toBe('Notification sent to the session owner.');
-    expect(notifyChannel).toHaveBeenCalledWith(
+    // Owner gets a DM with the full message
+    expect(notifyUser).toHaveBeenCalledWith(
       expect.stringContaining('Someone is waiting for Charger A'),
       expect.objectContaining({ appName: 'EV Charging' }),
       'driver@example.com',
     );
+    // Channel gets a brief mention-free note
+    expect(notifyChannel).toHaveBeenCalledWith(
+      expect.stringContaining('A request was sent to move a car at Charger A'),
+      expect.objectContaining({ appName: 'EV Charging' }),
+    );
   });
 
   it('returns failure message when notification fails', async () => {
     const charger = makeCharger({ activeSessionId: 'session-1' });
     const session = makeSession();
 
     setupDbMocks([[charger], [session]]);
-    (notifyChannel as ReturnType<typeof vi.fn>).mockResolvedValue(false);
+    (notifyUser as ReturnType<typeof vi.fn>).mockResolvedValue(false);
+    (notifyChannel as ReturnType<typeof vi.fn>).mockResolvedValue(true);
 
     const result = await notifyOwner('charger-1', nonAdminAuth);
 

web/src/lib/__tests__/reminders.test.ts

@@ -42,9 +42,11 @@ vi.mock('@/lib/strikes', () => ({
 }));
 
 const mockNotifyChannel = vi.fn().mockResolvedValue(true);
+const mockNotifyUser = vi.fn().mockResolvedValue(true);
 
 vi.mock('@/lib/notifications', () => ({
   notifyChannel: (...args: unknown[]) => mockNotifyChannel(...args),
+  notifyUser: (...args: unknown[]) => mockNotifyUser(...args),
   getSlackChannelMention: vi.fn((name: string) => `#${name}`),
 }));
 
@@ -149,7 +151,7 @@ describe('processSessionReminders', () => {
       const result = await processSessionReminders(now);
 
       expect(result.reminders10Sent).toBe(1);
-      expect(mockNotifyChannel).toHaveBeenCalledWith(
+      expect(mockNotifyUser).toHaveBeenCalledWith(
         expect.stringContaining('ends in 10 minutes'),
         expect.any(Object),
         'user@example.com',
@@ -198,7 +200,7 @@ describe('processSessionReminders', () => {
       const result = await processSessionReminders(now);
 
       expect(result.reminders5Sent).toBe(1);
-      expect(mockNotifyChannel).toHaveBeenCalledWith(
+      expect(mockNotifyUser).toHaveBeenCalledWith(
         expect.stringContaining('ends in 5 minutes'),
         expect.any(Object),
         'user@example.com',
@@ -397,7 +399,7 @@ describe('processSessionReminders', () => {
       const result = await processSessionReminders(now);
 
       expect(result.reservationUpcomingReminders).toBe(1);
-      expect(mockNotifyChannel).toHaveBeenCalledWith(
+      expect(mockNotifyUser).toHaveBeenCalledWith(
         expect.stringContaining('starts in 5 minutes'),
         expect.any(Object),
         'user@example.com',
@@ -414,7 +416,7 @@ describe('processSessionReminders', () => {
       const result = await processSessionReminders(now);
 
       expect(result.reservationLateReminders).toBe(1);
-      expect(mockNotifyChannel).toHaveBeenCalledWith(
+      expect(mockNotifyUser).toHaveBeenCalledWith(
         expect.stringContaining('will be released'),
         expect.any(Object),
         'user@example.com',

web/src/lib/notifications.ts

@@ -121,6 +121,46 @@ export async function sendEmailNotification(
   return true;
 }
 
+// ---------------------------------------------------------------------------
+// Slack DM (direct message via bot token)
+// ---------------------------------------------------------------------------
+
+/**
+ * Send a direct message to a Slack user identified by email.
+ * Opens (or reuses) the DM channel via conversations.open, then posts.
+ * Returns true on success, false on failure (never throws).
+ */
+export async function sendSlackDM(
+  token: string,
+  email: string,
+  text: string,
+): Promise<boolean> {
+  if (!token || !email) return false;
+
+  try {
+    const userId = await lookupSlackUserId(token, email);
+    if (!userId) return false;
+
+    const openResponse = await fetch('https://slack.com/api/conversations.open', {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${token}`,
+      },
+      body: JSON.stringify({ users: userId }),
+    });
+
+    if (!openResponse.ok) return false;
+    const openData = await openResponse.json();
+    if (!openData.ok || !openData.channel?.id) return false;
+
+    return sendSlackChannelMessage(token, openData.channel.id, text);
+  } catch (err) {
+    console.error('[SLACK DM] Failed to send DM:', err);
+    return false;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Unified channel notification (mirrors notifyChannel_ from engine.js)
 // ---------------------------------------------------------------------------
@@ -194,6 +234,31 @@ export async function notifyChannel(
   return sentSlack || sentEmail;
 }
 
+// ---------------------------------------------------------------------------
+// Direct user notification (DM-first, email fallback)
+// ---------------------------------------------------------------------------
+
+/**
+ * Send a notification directly to a user via Slack DM, falling back to email.
+ * Use this for personal reminders that should not flood the channel.
+ *
+ * Returns true if at least one notification was sent.
+ */
+export async function notifyUser(
+  text: string,
+  config: NotifyChannelConfig,
+  targetEmail?: string,
+): Promise<boolean> {
+  if (!targetEmail) return false;
+
+  if (config.slackBotToken) {
+    const sent = await sendSlackDM(config.slackBotToken, targetEmail, text);
+    if (sent) return true;
+  }
+
+  return sendEmailNotification(targetEmail, `${config.appName} notification`, text);
+}
+
 // ---------------------------------------------------------------------------
 // Message builders
 // ---------------------------------------------------------------------------

web/src/lib/reminders.ts

@@ -24,6 +24,7 @@ import {
 } from '@/lib/utils';
 import {
   notifyChannel,
+  notifyUser,
   getSlackChannelMention,
   type NotifyChannelConfig,
 } from '@/lib/notifications';
@@ -204,9 +205,9 @@ export async function processSessionReminders(now: Date): Promise<ReminderResult
         updates.complete = false;
       }
 
-      // 10-minute reminder
+      // 10-minute reminder — DM only (personal, pre-emptive)
       if (reminder10Enabled && !session.reminder10Sent && minutesToEnd <= 10 && minutesToEnd > 5) {
-        const sent = await notifyChannel(
+        const sent = await notifyUser(
           buildSessionReminderText('tminus10', session, charger, endTime, appName, channelMention, sessionMoveGraceMinutes),
           notifyConfig,
           session.userId,
@@ -217,9 +218,9 @@ export async function processSessionReminders(now: Date): Promise<ReminderResult
         }
       }
 
-      // 5-minute reminder
+      // 5-minute reminder — DM only (personal, pre-emptive)
       if (reminder5Enabled && !session.reminder5Sent && minutesToEnd <= 5 && minutesToEnd > 0) {
-        const sent = await notifyChannel(
+        const sent = await notifyUser(
           buildSessionReminderText('tminus5', session, charger, endTime, appName, channelMention, sessionMoveGraceMinutes),
           notifyConfig,
           session.userId,
@@ -329,9 +330,9 @@ export async function processSessionReminders(now: Date): Promise<ReminderResult
 
       const resUpdates: Record<string, unknown> = {};
 
-      // 5 minutes before start reminder
+      // 5 minutes before start reminder — DM only (personal)
       if (!reservation.reminder5BeforeSent && minutesToStart <= 5 && minutesToStart > 0) {
-        const sent = await notifyChannel(
+        const sent = await notifyUser(
           buildReservationReminderText('upcoming', reservation, charger, startTime, reservationConfig.lateGraceMinutes, appName),
           notifyConfig,
           reservation.userId,
@@ -342,13 +343,13 @@ export async function processSessionReminders(now: Date): Promise<ReminderResult
         }
       }
 
-      // 5 minutes after start (late) reminder
+      // 5 minutes after start (late) reminder — DM only (personal, still actionable)
       if (
         !reservation.reminder5AfterSent &&
         minutesSinceStart >= 5 &&
         minutesSinceStart < reservationConfig.lateGraceMinutes
       ) {
-        const sent = await notifyChannel(
+        const sent = await notifyUser(
           buildReservationReminderText('late', reservation, charger, startTime, reservationConfig.lateGraceMinutes, appName),
           notifyConfig,
           reservation.userId,