We Cut Meeting Time by 40% with Slack and Calendly: 2026 Productivity Retrospective

// slack-meeting-validator.ts
// Slack CLI v2.3.1 custom workflow function to validate meeting agendas
// and auto-cancel low-value meetings before they consume calendar time
// Dependencies: Slack CLI 2.3.1, Calendly API v3.2.0, Harvest API v2
import { SlackFunction, SlackError } from "https://deno.land/x/slack_cli@v2.3.1/mod.ts";
import { Client as CalendlyClient } from "https://deno.land/x/calendly@v3.2.0/mod.ts";
import { HarvestClient } from "https://deno.land/x/harvest@v0.9.0/mod.ts";

// Runtime environment variable validation
const requiredEnvVars = [
  "SLACK_BOT_TOKEN",
  "CALENDLY_API_KEY",
  "CALENDLY_ORG_URI",
  "HARVEST_ACCOUNT_ID",
  "HARVEST_TOKEN",
  "MEETING_AGENDA_MIN_LENGTH"
] as const;

type EnvVar = typeof requiredEnvVars[number];
const env: Record = {} as Record;

for (const varName of requiredEnvVars) {
  const value = Deno.env.get(varName);
  if (!value) {
    throw new Error(`Missing required environment variable: ${varName}`);
  }
  env[varName] = value;
}

// Initialize API clients with typed config
const slack = new SlackFunction(env.SLACK_BOT_TOKEN);
const calendly = new CalendlyClient({ apiKey: env.CALENDLY_API_KEY });
const harvest = new HarvestClient({
  accountId: env.HARVEST_ACCOUNT_ID,
  token: env.HARVEST_TOKEN,
});

// Minimum agenda length in characters to consider a meeting valid
const MIN_AGENDA_LENGTH = parseInt(env.MEETING_AGENDA_MIN_LENGTH, 10);

/**
 * Slack workflow trigger: fires when a new calendar event is created
 * via Slack's calendar integration or Calendly webhook
 */
export default SlackFunction(
  async ({ event, context }) => {
    try {
      // Only process events with type "calendar_event_created"
      if (event.type !== "calendar_event_created") {
        return { ok: true, message: "Ignoring non-calendar event" };
      }

      const { event_id, summary, description, attendees, organizer_id } = event.payload;

      // Skip events organized by execs or external partners (we don't police those)
      const skipDomains = ["exec.example.com", "partner.example.com"];
      const organizer = await slack.users.info({ user: organizer_id });
      if (organizer.ok && skipDomains.some(domain => organizer.user.email.includes(domain))) {
        return { ok: true, message: "Skipping executive/partner event" };
      }

      // Check if agenda (description) meets minimum length
      const agendaLength = description?.trim().length || 0;
      if (agendaLength >= MIN_AGENDA_LENGTH) {
        // Log valid meeting to Harvest for time tracking calibration
        await harvest.timeEntries.create({
          project_id: 12345, // Internal "Meeting Quality" project ID
          task_id: 67890, // "Valid Meeting" task ID
          spent_date: new Date().toISOString().split("T")[0],
          hours: 0.1, // 6 minutes: time spent creating agenda
          notes: `Valid agenda for event ${event_id}: ${summary}`,
        });
        return { ok: true, message: "Meeting agenda valid, no action taken" };
      }

      // Invalid agenda: cancel event via Calendly API if it's a Calendly-scheduled event
      if (event.payload.scheduling_tool === "calendly") {
        const calendlyEventId = event.payload.external_event_id;
        try {
          await calendly.events.cancel(calendlyEventId);
          // Notify organizer in Slack
          await slack.chat.postMessage({
            channel: organizer_id,
            text: `🚫 Your meeting "${summary}" was cancelled because it has no agenda (minimum ${MIN_AGENDA_LENGTH} characters). Add an agenda and reschedule via .`,
            blocks: [
              {
                type: "section",
                text: {
                  type: "mrkdwn",
                  text: `🚫 *Meeting Cancelled*
Your meeting "${summary}" (ID: ${event_id}) was cancelled due to missing agenda.`,
                },
              },
              {
                type: "section",
                text: {
                  type: "mrkdwn",
                  text: `Add an agenda with at least ${MIN_AGENDA_LENGTH} characters and reschedule: `,
                },
              },
            ],
          });
          // Log cancellation to Harvest
          await harvest.timeEntries.create({
            project_id: 12345,
            task_id: 67891, // "Cancelled Meeting" task ID
            spent_date: new Date().toISOString().split("T")[0],
            hours: 0.1,
            notes: `Cancelled event ${event_id}: ${summary} (agenda length: ${agendaLength})`,
          });
          return { ok: true, message: "Meeting cancelled, organizer notified" };
        } catch (calendlyError) {
          console.error(`Failed to cancel Calendly event ${calendlyEventId}:`, calendlyError);
          // Fallback: post to #engineering-ops channel for manual review
          await slack.chat.postMessage({
            channel: "C12345678", // #engineering-ops channel ID
            text: `⚠️ Failed to auto-cancel meeting "${summary}" (ID: ${event_id}). Agenda too short, manual review needed.`,
          });
        }
      } else {
        // Non-Calendly event: post warning to organizer
        await slack.chat.postMessage({
          channel: organizer_id,
          text: `⚠️ Your meeting "${summary}" has no agenda (minimum ${MIN_AGENDA_LENGTH} characters). Add an agenda to avoid future auto-cancellations.`,
        });
      }

      return { ok: true, message: "Meeting processed" };
    } catch (error) {
      console.error("Workflow execution failed:", error);
      // Report error to Slack ops channel
      await slack.chat.postMessage({
        channel: "C12345678",
        text: `🔥 Slack meeting validator workflow failed: ${error.message}`,
      });
      return { ok: false, error: error.message };
    }
  }
);

// calendly-slack-status-sync.js
// Node.js v20+ script to sync Calendly scheduled events to Slack user statuses
// Uses Calendly API v3.2.0 and Slack Web API v7.0.0
// Run via cron every 5 minutes to update statuses in real time
import { Calendly } from "@calendly/api-client";
import { WebClient as SlackClient } from "@slack/web-api";
import dotenv from "dotenv";
import fetch from "node-fetch";

// Load environment variables from .env file
dotenv.config();

// Validate required env vars
const requiredVars = [
  "CALENDLY_API_KEY",
  "CALENDLY_ORG_URI",
  "SLACK_BOT_TOKEN",
  "SLACK_TEAM_ID",
];
for (const varName of requiredVars) {
  if (!process.env[varName]) {
    throw new Error(`Missing required environment variable: ${varName}`);
  }
}

// Initialize API clients
const calendly = new Calendly({ apiKey: process.env.CALENDLY_API_KEY });
const slack = new SlackClient(process.env.SLACK_BOT_TOKEN);

// Cache of active Slack statuses to avoid redundant API calls
const statusCache = new Map();

/**
 * Fetches all upcoming Calendly events for the organization
 * @returns {Promise} List of upcoming Calendly events
 */
async function fetchUpcomingCalendlyEvents() {
  try {
    const { data } = await calendly.events.list({
      organization: process.env.CALENDLY_ORG_URI,
      status: "active",
      min_start_time: new Date().toISOString(),
      max_start_time: new Date(Date.now() + 3600000).toISOString(), // Next hour
    });
    return data;
  } catch (error) {
    console.error("Failed to fetch Calendly events:", error);
    throw error;
  }
}

/**
 * Maps Calendly event to Slack status payload
 * @param {Object} event Calendly event object
 * @returns {Object} Slack status payload
 */
function mapEventToSlackStatus(event) {
  const startTime = new Date(event.start_time);
  const endTime = new Date(event.end_time);
  const now = new Date();

  // Only set status if event is currently active
  if (now < startTime || now > endTime) {
    return null;
  }

  const attendeeEmails = event.invitees.map(invitee => invitee.email);
  return {
    profile: {
      status_text: `In ${event.name} (ends ${endTime.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" })})`,
      status_emoji: ":calendar:",
      status_expiration: Math.floor(endTime.getTime() / 1000),
    },
    emails: attendeeEmails,
  };
}

/**
 * Fetches Slack user ID by email
 * @param {string} email User email address
 * @returns {Promise} Slack user ID or null
 */
async function getSlackUserIdByEmail(email) {
  try {
    const { user } = await slack.users.lookupByEmail({ email });
    return user.id;
  } catch (error) {
    console.error(`Failed to find Slack user for email ${email}:`, error);
    return null;
  }
}

/**
 * Updates Slack user status
 * @param {string} userId Slack user ID
 * @param {Object} status Slack status payload
 */
async function updateSlackStatus(userId, status) {
  // Check cache to avoid redundant updates
  const cacheKey = `${userId}-${status.profile.status_expiration}`;
  if (statusCache.has(cacheKey)) {
    return;
  }

  try {
    await slack.users.profile.set({
      user: userId,
      profile: status.profile,
    });
    statusCache.set(cacheKey, true);
    // Clear cache entry when status expires
    setTimeout(() => statusCache.delete(cacheKey), status.profile.status_expiration * 1000 - Date.now());
    console.log(`Updated Slack status for user ${userId}`);
  } catch (error) {
    console.error(`Failed to update Slack status for user ${userId}:`, error);
  }
}

// Main execution flow
async function main() {
  try {
    console.log("Starting Calendly -> Slack status sync...");
    const events = await fetchUpcomingCalendlyEvents();
    console.log(`Fetched ${events.length} upcoming events`);

    for (const event of events) {
      const statusPayload = mapEventToSlackStatus(event);
      if (!statusPayload) continue;

      for (const email of statusPayload.emails) {
        const userId = await getSlackUserIdByEmail(email);
        if (!userId) continue;
        await updateSlackStatus(userId, statusPayload);
      }
    }

    console.log("Sync completed successfully");
  } catch (error) {
    console.error("Main execution failed:", error);
    process.exit(1);
  }
}

// Run main function and handle uncaught rejections
main();
process.on("unhandledRejection", (error) => {
  console.error("Unhandled promise rejection:", error);
  process.exit(1);
});

// slack-slash-command-schedule.js
// Express.js v4.18+ server to handle /schedule Slack slash command
// Integrates with Calendly API v3.2.0 to create meetings without leaving Slack
import express from "express";
import { Calendly } from "@calendly/api-client";
import { WebClient as SlackClient } from "@slack/web-api";
import dotenv from "dotenv";
import bodyParser from "body-parser";
import crypto from "crypto";

dotenv.config();

// Validate env vars
const requiredVars = [
  "SLACK_SIGNING_SECRET",
  "SLACK_BOT_TOKEN",
  "CALENDLY_API_KEY",
  "CALENDLY_USER_URI",
  "PORT",
];
for (const varName of requiredVars) {
  if (!process.env[varName]) {
    throw new Error(`Missing required environment variable: ${varName}`);
  }
}

const app = express();
const slack = new SlackClient(process.env.SLACK_BOT_TOKEN);
const calendly = new Calendly({ apiKey: process.env.CALENDLY_API_KEY });

// Slack requires urlencoded body with type application/x-www-form-urlencoded
app.use(bodyParser.urlencoded({ extended: true }));

/**
 * Verifies Slack request signature to prevent spoofing
 * @param {Object} req Express request object
 * @returns {boolean} True if signature is valid
 */
function verifySlackSignature(req) {
  const signature = req.headers["x-slack-signature"];
  const timestamp = req.headers["x-slack-request-timestamp"];
  const body = req.rawBody;

  // Check timestamp is within 5 minutes to prevent replay attacks
  const fiveMinutesAgo = Math.floor(Date.now() / 1000) - 300;
  if (timestamp < fiveMinutesAgo) {
    return false;
  }

  const sigBasestring = `v0:${timestamp}:${body}`;
  const hmac = crypto.createHmac("sha256", process.env.SLACK_SIGNING_SECRET);
  hmac.update(sigBasestring);
  const computedSignature = `v0=${hmac.digest("hex")}`;

  return crypto.timingSafeEqual(
    Buffer.from(computedSignature),
    Buffer.from(signature)
  );
}

/**
 * Parses slash command arguments to extract meeting details
 * @param {string} text Slash command text (e.g., "/schedule 30m Sync with @alice #project-x")
 * @returns {Object} Parsed meeting details
 */
function parseMeetingArgs(text) {
  const args = text.trim().split(/\s+/);
  let duration = 30; // Default 30 minutes
  let attendees = [];
  let topic = "Quick Sync";

  // Extract duration (e.g., 30m, 1h)
  const durationRegex = /^(\d+)(m|h)$/;
  for (let i = 0; i < args.length; i++) {
    const match = args[i].match(durationRegex);
    if (match) {
      duration = match[2] === "h" ? parseInt(match[1]) * 60 : parseInt(match[1]);
      args.splice(i, 1);
      break;
    }
  }

  // Extract attendees (Slack user IDs starting with @)
  const attendeeRegex = /^<@([A-Z0-9]+)>$/;
  for (let i = 0; i < args.length; i++) {
    const match = args[i].match(attendeeRegex);
    if (match) {
      attendees.push(match[1]);
      args.splice(i, 1);
      i--;
    }
  }

  // Remaining text is topic
  topic = args.join(" ") || "Quick Sync";

  return { duration, attendees, topic };
}

// Handle /schedule slash command
app.post("/slack/schedule", async (req, res) => {
  try {
    // Verify Slack signature
    if (!verifySlackSignature(req)) {
      return res.status(401).send("Invalid Slack signature");
    }

    const { user_id, text, channel_id } = req.body;
    const { duration, attendees, topic } = parseMeetingArgs(text);

    // Create Calendly event
    const startTime = new Date(Date.now() + 3600000); // 1 hour from now
    const endTime = new Date(startTime.getTime() + duration * 60000);
    const calendlyEvent = await calendly.events.create({
      organization: process.env.CALENDLY_ORG_URI,
      name: topic,
      start_time: startTime.toISOString(),
      end_time: endTime.toISOString(),
      location: { type: "zoom" }, // Default to Zoom
      invitees: [
        { email: user_id }, // Add organizer
        ...attendees.map(id => ({ email: id })), // Add attendees
      ],
    });

    // Send confirmation to Slack channel
    await slack.chat.postMessage({
      channel: channel_id,
      text: `📅 Scheduled "${topic}" for ${duration} minutes starting at ${startTime.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" })}`,
      blocks: [
        {
          type: "section",
          text: {
            type: "mrkdwn",
            text: `📅 *Meeting Scheduled*
*Topic:* ${topic}
*Duration:* ${duration} minutes
*Start Time:* ${startTime.toLocaleString()}
*Calendly Link:* ${calendlyEvent.data.resource.location.join_url}`,
          },
        },
        {
          type: "actions",
          elements: [
            {
              type: "button",
              text: { type: "plain_text", text: "Cancel Meeting" },
              style: "danger",
              value: calendlyEvent.data.resource.uri,
            },
          ],
        },
      ],
    });

    res.status(200).send();
  } catch (error) {
    console.error("Slash command handler failed:", error);
    res.status(500).send("Failed to schedule meeting");
  }
});

const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
  console.log(`Slack /schedule command server running on port ${PORT}`);
});

// Agenda validation snippet from slack-meeting-validator.ts
const agendaLength = description?.trim().length || 0;
if (agendaLength < MIN_AGENDA_LENGTH) {
  await calendly.events.cancel(event.payload.external_event_id);
  await slack.chat.postMessage({
    channel: organizer_id,
    text: `Meeting cancelled: agenda too short (${agendaLength}/${MIN_AGENDA_LENGTH} chars)`,
  });
}

// Slash command parsing snippet from slack-slash-command-schedule.js
const { duration, attendees, topic } = parseMeetingArgs(text);
const startTime = new Date(Date.now() + 3600000);
const endTime = new Date(startTime.getTime() + duration * 60000);
const calendlyEvent = await calendly.events.create({
  name: topic,
  start_time: startTime.toISOString(),
  end_time: endTime.toISOString(),
  invitees: [{ email: user_id }, ...attendees.map(id => ({ email: id }))],
});

// Status mapping snippet from calendly-slack-status-sync.js
function mapEventToSlackStatus(event) {
  const startTime = new Date(event.start_time);
  const endTime = new Date(event.end_time);
  const now = new Date();
  if (now < startTime || now > endTime) return null;
  return {
    profile: {
      status_text: `In ${event.name} (ends ${endTime.toLocaleTimeString("en-US", { hour: "2-digit", minute: "2-digit" })})`,
      status_emoji: ":calendar:",
      status_expiration: Math.floor(endTime.getTime() / 1000),
    },
    emails: event.invitees.map(invitee => invitee.email),
  };
}