agent-slack 0.6.1 → 0.7.1

package/dist/index.js

@@ -1819,6 +1819,41 @@ class SlackApiClient {
       this.web = new WebClient(auth.token);
     }
   }
+  async apiMultipart(method, params = {}) {
+    if (this.auth.auth_type === "standard") {
+      return this.api(method, params);
+    }
+    if (!this.workspaceUrl) {
+      throw new Error("Browser auth requires workspace URL.");
+    }
+    const auth = this.auth;
+    const url = `${this.workspaceUrl.replace(/\/$/, "")}/api/${method}`;
+    const fd = new FormData;
+    fd.append("token", auth.xoxc_token);
+    for (const [k, v] of Object.entries(params)) {
+      if (v !== undefined) {
+        fd.append(k, typeof v === "object" ? JSON.stringify(v) : String(v));
+      }
+    }
+    const response = await fetch(url, {
+      method: "POST",
+      headers: {
+        Cookie: `d=${encodeURIComponent(auth.xoxd_cookie)}`,
+        Origin: "https://app.slack.com",
+        "User-Agent": getUserAgent()
+      },
+      body: fd
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      throw new Error(`Slack HTTP ${response.status} calling ${method}`);
+    }
+    if (!isRecord3(data) || data.ok !== true) {
+      const error = isRecord3(data) && typeof data.error === "string" ? data.error : null;
+      throw new Error(error || `Slack API error calling ${method}`);
+    }
+    return data;
+  }
   async api(method, params = {}) {
     if (this.auth.auth_type === "standard") {
       if (!this.web) {
@@ -7171,6 +7206,569 @@ function registerSearchCommand(input) {
   create({ kind: "files", name: "files", desc: "Search files" });
 }
 
+// src/slack/later.ts
+async function fetchLaterItems(client, options) {
+  const stateFilter = options?.state ?? "in_progress";
+  const limit = options?.limit ?? 20;
+  const maxBodyChars = options?.maxBodyChars ?? 4000;
+  const countsOnly = options?.countsOnly ?? false;
+  let currentCursor = options?.cursor;
+  let allRawItems = [];
+  let counts = {};
+  let nextCursor;
+  while (true) {
+    const resp = await client.api("saved.list", {
+      limit: 50,
+      cursor: currentCursor
+    });
+    if (!currentCursor) {
+      counts = isRecord5(resp.counts) ? resp.counts : {};
+    }
+    const pageRawItems = asArray2(resp.saved_items).filter(isRecord5);
+    allRawItems.push(...pageRawItems);
+    const meta = isRecord5(resp.response_metadata) ? resp.response_metadata : null;
+    nextCursor = meta ? getString4(meta.next_cursor) : undefined;
+    if (countsOnly) {
+      break;
+    }
+    let filtered2 = allRawItems.filter((item) => getString4(item.item_type) === "message");
+    if (stateFilter !== "all") {
+      filtered2 = filtered2.filter((item) => getString4(item.state) === stateFilter);
+    }
+    if (filtered2.length >= limit || !nextCursor) {
+      break;
+    }
+    currentCursor = nextCursor;
+  }
+  const result = {
+    counts: {
+      in_progress: getNumber3(counts.uncompleted_count) ?? 0,
+      archived: getNumber3(counts.archived_count) ?? 0,
+      completed: getNumber3(counts.completed_count) ?? 0,
+      total: getNumber3(counts.total_count) ?? 0
+    },
+    items: [],
+    next_cursor: nextCursor
+  };
+  if (countsOnly) {
+    return result;
+  }
+  let filtered = allRawItems.filter((item) => getString4(item.item_type) === "message");
+  if (stateFilter !== "all") {
+    filtered = filtered.filter((item) => getString4(item.state) === stateFilter);
+  }
+  filtered = filtered.slice(0, limit);
+  result.items = await Promise.all(filtered.map(async (item) => {
+    const channelId = getString4(item.item_id) ?? "";
+    const ts = getString4(item.ts) ?? "";
+    const state = getString4(item.state) ?? "in_progress";
+    const dateSaved = getNumber3(item.date_created) ?? 0;
+    const dateCompleted = getNumber3(item.date_completed);
+    let channelName;
+    let message;
+    try {
+      const info = await client.api("conversations.info", {
+        channel: channelId
+      });
+      const ch = isRecord5(info.channel) ? info.channel : null;
+      if (ch) {
+        channelName = getString4(ch.name) ?? getString4(ch.name_normalized) ?? undefined;
+        if (ch.is_im && !channelName) {
+          const userId = getString4(ch.user);
+          if (userId) {
+            try {
+              const userInfo = await client.api("users.info", { user: userId });
+              const u = isRecord5(userInfo.user) ? userInfo.user : null;
+              const profile = u && isRecord5(u.profile) ? u.profile : null;
+              channelName = getString4(profile?.display_name) || getString4(u?.real_name) || getString4(u?.name) || undefined;
+            } catch {}
+          }
+        }
+      }
+    } catch {}
+    if (ts) {
+      try {
+        const history = await client.api("conversations.history", {
+          channel: channelId,
+          latest: ts,
+          inclusive: true,
+          limit: 1
+        });
+        const msgs = asArray2(history.messages).filter(isRecord5);
+        const msg = msgs.find((m) => getString4(m.ts) === ts);
+        if (msg) {
+          const rendered = renderSlackMessageContent(msg);
+          const content = maxBodyChars >= 0 && rendered.length > maxBodyChars ? `${rendered.slice(0, maxBodyChars)}
+…` : rendered;
+          message = {
+            author: getString4(msg.user) || getString4(msg.bot_id) ? {
+              user_id: getString4(msg.user) ?? undefined,
+              bot_id: getString4(msg.bot_id) ?? undefined
+            } : undefined,
+            content: content || undefined,
+            thread_ts: getString4(msg.thread_ts) ?? undefined,
+            reply_count: getNumber3(msg.reply_count) ?? undefined
+          };
+        }
+      } catch {}
+    }
+    return {
+      channel_id: channelId,
+      channel_name: channelName,
+      ts,
+      state,
+      date_saved: dateSaved,
+      date_completed: dateCompleted && dateCompleted > 0 ? dateCompleted : undefined,
+      message
+    };
+  }));
+  return result;
+}
+async function updateLaterMark(client, input) {
+  await client.apiMultipart("saved.update", {
+    item_id: input.channelId,
+    item_type: "message",
+    ts: input.ts,
+    mark: input.mark
+  });
+}
+async function saveLater(client, input) {
+  await client.api("saved.add", {
+    item_id: input.channelId,
+    item_type: "message",
+    ts: input.ts
+  });
+}
+async function removeLater(client, input) {
+  await client.api("saved.delete", {
+    item_id: input.channelId,
+    item_type: "message",
+    ts: input.ts
+  });
+}
+async function setLaterReminder(client, input) {
+  await client.apiMultipart("saved.update", {
+    item_id: input.channelId,
+    item_type: "message",
+    ts: input.ts,
+    date_due: String(input.dateDue)
+  });
+}
+function parseReminderDuration(input) {
+  const now = Math.floor(Date.now() / 1000);
+  const trimmed = input.trim().toLowerCase();
+  const relMatch = trimmed.match(/^(\d+(?:\.\d+)?)\s*(m|min|mins|minutes?|h|hr|hrs|hours?|d|days?)$/);
+  if (relMatch) {
+    const amount = Number.parseFloat(relMatch[1]);
+    const unit = relMatch[2].charAt(0);
+    if (unit === "m") {
+      return now + amount * 60;
+    }
+    if (unit === "h") {
+      return now + amount * 3600;
+    }
+    if (unit === "d") {
+      return now + amount * 86400;
+    }
+  }
+  const tomorrow9am = getNext9am(1);
+  if (trimmed === "tomorrow") {
+    return tomorrow9am;
+  }
+  const dayNames = ["sunday", "monday", "tuesday", "wednesday", "thursday", "friday", "saturday"];
+  const dayIndex = dayNames.indexOf(trimmed);
+  if (dayIndex >= 0) {
+    const today = new Date;
+    const currentDay = today.getDay();
+    let daysUntil = dayIndex - currentDay;
+    if (daysUntil <= 0) {
+      daysUntil += 7;
+    }
+    return getNext9am(daysUntil);
+  }
+  const asNum = Number(trimmed);
+  if (!Number.isNaN(asNum) && asNum > 1e9) {
+    return asNum;
+  }
+  throw new Error(`Invalid duration: "${input}". Use: 30m, 1h, 3h, 2d, tomorrow, monday, or a unix timestamp.`);
+}
+function getNext9am(daysFromNow) {
+  const date = new Date;
+  date.setDate(date.getDate() + daysFromNow);
+  date.setHours(9, 0, 0, 0);
+  return Math.floor(date.getTime() / 1000);
+}
+function isRecord5(value) {
+  return typeof value === "object" && value !== null;
+}
+function asArray2(value) {
+  return Array.isArray(value) ? value : [];
+}
+function getString4(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function getNumber3(value) {
+  return typeof value === "number" ? value : undefined;
+}
+
+// src/cli/later-command.ts
+function resolveTargetRef(input) {
+  const { targetInput, options, ctx } = input;
+  const target = parseMsgTarget(targetInput);
+  if (target.kind === "url") {
+    return {
+      workspaceUrl: target.ref.workspace_url,
+      getChannelAndTs: async () => ({
+        channelId: target.ref.channel_id,
+        ts: target.ref.message_ts
+      })
+    };
+  }
+  const workspaceUrl = ctx.effectiveWorkspaceUrl(options.workspace);
+  const ts = options.ts?.trim();
+  if (!ts) {
+    throw new Error('When targeting a channel, you must pass --ts "<seconds>.<micros>"');
+  }
+  return {
+    workspaceUrl,
+    getChannelAndTs: async (client) => {
+      const channelId = await resolveChannelId(client, target.kind === "channel" ? target.channel : targetInput);
+      return { channelId, ts };
+    }
+  };
+}
+function registerLaterCommand(input) {
+  const laterCmd = input.program.command("later").description("Manage saved-for-later messages (Slack's Later tab)");
+  laterCmd.command("list", { isDefault: true }).description("List saved-for-later messages").option("--workspace <url>", "Workspace URL (defaults to your configured workspace)").option("--state <state>", "Filter by state: in_progress (default), archived, completed, all", "in_progress").option("--limit <n>", "Max items to show (default 20)", "20").option("--max-body-chars <n>", "Max content characters per message (default 4000, -1 for unlimited)", "4000").option("--counts-only", "Only show counts per state, skip message content").action(async (options) => {
+    try {
+      const workspaceUrl = input.ctx.effectiveWorkspaceUrl(options.workspace);
+      const state = parseState(options.state ?? "in_progress");
+      const payload = await input.ctx.withAutoRefresh({
+        workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+          return fetchLaterItems(client, {
+            state,
+            limit: Number.parseInt(options.limit ?? "20", 10),
+            maxBodyChars: Number.parseInt(options.maxBodyChars ?? "4000", 10),
+            countsOnly: options.countsOnly
+          });
+        }
+      });
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  laterCmd.command("complete").description("Mark a saved message as completed").argument("<target>", "Slack message URL or channel ID").option("--workspace <url>", "Workspace URL").option("--ts <ts>", "Message ts (required when using channel ID)").action(async (...args) => {
+    const [targetInput, options] = args;
+    try {
+      const ref = resolveTargetRef({ targetInput, options, ctx: input.ctx });
+      await input.ctx.withAutoRefresh({
+        workspaceUrl: ref.workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(ref.workspaceUrl);
+          const { channelId, ts } = await ref.getChannelAndTs(client);
+          await updateLaterMark(client, { channelId, ts, mark: "completed" });
+        }
+      });
+      console.log(JSON.stringify({ ok: true }));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  laterCmd.command("archive").description("Archive a saved message").argument("<target>", "Slack message URL or channel ID").option("--workspace <url>", "Workspace URL").option("--ts <ts>", "Message ts (required when using channel ID)").action(async (...args) => {
+    const [targetInput, options] = args;
+    try {
+      const ref = resolveTargetRef({ targetInput, options, ctx: input.ctx });
+      await input.ctx.withAutoRefresh({
+        workspaceUrl: ref.workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(ref.workspaceUrl);
+          const { channelId, ts } = await ref.getChannelAndTs(client);
+          await updateLaterMark(client, { channelId, ts, mark: "archived" });
+        }
+      });
+      console.log(JSON.stringify({ ok: true }));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  laterCmd.command("reopen").description("Move a saved message back to in-progress").argument("<target>", "Slack message URL or channel ID").option("--workspace <url>", "Workspace URL").option("--ts <ts>", "Message ts (required when using channel ID)").action(async (...args) => {
+    const [targetInput, options] = args;
+    try {
+      const ref = resolveTargetRef({ targetInput, options, ctx: input.ctx });
+      await input.ctx.withAutoRefresh({
+        workspaceUrl: ref.workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(ref.workspaceUrl);
+          const { channelId, ts } = await ref.getChannelAndTs(client);
+          await Promise.allSettled([
+            updateLaterMark(client, { channelId, ts, mark: "uncompleted" }),
+            updateLaterMark(client, { channelId, ts, mark: "unarchived" })
+          ]);
+        }
+      });
+      console.log(JSON.stringify({ ok: true }));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  laterCmd.command("save").description("Save a message for later").argument("<target>", "Slack message URL or channel ID").option("--workspace <url>", "Workspace URL").option("--ts <ts>", "Message ts (required when using channel ID)").action(async (...args) => {
+    const [targetInput, options] = args;
+    try {
+      const ref = resolveTargetRef({ targetInput, options, ctx: input.ctx });
+      await input.ctx.withAutoRefresh({
+        workspaceUrl: ref.workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(ref.workspaceUrl);
+          const { channelId, ts } = await ref.getChannelAndTs(client);
+          await saveLater(client, { channelId, ts });
+        }
+      });
+      console.log(JSON.stringify({ ok: true }));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  laterCmd.command("remove").description("Remove a message from Later entirely").argument("<target>", "Slack message URL or channel ID").option("--workspace <url>", "Workspace URL").option("--ts <ts>", "Message ts (required when using channel ID)").action(async (...args) => {
+    const [targetInput, options] = args;
+    try {
+      const ref = resolveTargetRef({ targetInput, options, ctx: input.ctx });
+      await input.ctx.withAutoRefresh({
+        workspaceUrl: ref.workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(ref.workspaceUrl);
+          const { channelId, ts } = await ref.getChannelAndTs(client);
+          await removeLater(client, { channelId, ts });
+        }
+      });
+      console.log(JSON.stringify({ ok: true }));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  laterCmd.command("remind").description("Set a reminder for a saved message").argument("<target>", "Slack message URL or channel ID").requiredOption("--in <duration>", "When to remind: 30m, 1h, 3h, 2d, tomorrow, monday, etc.").option("--workspace <url>", "Workspace URL").option("--ts <ts>", "Message ts (required when using channel ID)").action(async (...args) => {
+    const [targetInput, options] = args;
+    try {
+      const ref = resolveTargetRef({ targetInput, options, ctx: input.ctx });
+      const reminderTime = parseReminderDuration(options.in);
+      await input.ctx.withAutoRefresh({
+        workspaceUrl: ref.workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(ref.workspaceUrl);
+          const { channelId, ts } = await ref.getChannelAndTs(client);
+          await setLaterReminder(client, { channelId, ts, dateDue: reminderTime });
+        }
+      });
+      console.log(JSON.stringify({
+        ok: true,
+        remind_at: reminderTime
+      }));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+}
+function parseState(value) {
+  const v = value.toLowerCase().trim();
+  if (v === "in_progress" || v === "in-progress" || v === "active" || v === "open") {
+    return "in_progress";
+  }
+  if (v === "archived" || v === "archive") {
+    return "archived";
+  }
+  if (v === "completed" || v === "complete" || v === "done") {
+    return "completed";
+  }
+  if (v === "all") {
+    return "all";
+  }
+  return "in_progress";
+}
+
+// src/slack/unreads.ts
+async function fetchUnreads(client, options) {
+  const includeMessages = options?.includeMessages ?? true;
+  const maxMessages = options?.maxMessagesPerChannel ?? 10;
+  const maxBodyChars = options?.maxBodyChars ?? 4000;
+  const skipSystem = options?.skipSystemMessages ?? true;
+  const resp = await client.api("client.counts", {
+    thread_count_by_channel: true
+  });
+  const channels = asArray3(resp.channels).filter(isRecord6);
+  const mpims = asArray3(resp.mpims).filter(isRecord6);
+  const ims = asArray3(resp.ims).filter(isRecord6);
+  const allEntries = [
+    ...channels.map((c) => ({ ...c, type: "channel" })),
+    ...mpims.map((c) => ({ ...c, type: "mpim" })),
+    ...ims.map((c) => ({ ...c, type: "dm" }))
+  ];
+  const withUnreads = allEntries.filter((c) => c.has_unreads);
+  const channelInfos = await Promise.all(withUnreads.map(async (entry) => {
+    const channelInfoPromise = (async () => {
+      let name;
+      let { type } = entry;
+      try {
+        const info = await client.api("conversations.info", {
+          channel: entry.id
+        });
+        const ch = isRecord6(info.channel) ? info.channel : null;
+        if (ch) {
+          name = getString5(ch.name) ?? getString5(ch.name_normalized) ?? undefined;
+          if (ch.is_im) {
+            type = "dm";
+            const userId = getString5(ch.user);
+            if (userId && !name) {
+              try {
+                const userInfo = await client.api("users.info", { user: userId });
+                const u = isRecord6(userInfo.user) ? userInfo.user : null;
+                const profile = u && isRecord6(u.profile) ? u.profile : null;
+                name = getString5(profile?.display_name) || getString5(u?.real_name) || getString5(u?.name) || undefined;
+              } catch {}
+            }
+          } else if (ch.is_mpim) {
+            type = "mpim";
+          } else if (ch.is_group || ch.is_private) {
+            type = "group";
+          } else {
+            type = "channel";
+          }
+        }
+      } catch {}
+      return { name, type };
+    })();
+    const historyPromise = (async () => {
+      let messages;
+      let unreadCount = entry.unread_count_display ?? entry.unread_count ?? (entry.has_unreads ? 1 : 0);
+      if (includeMessages && entry.last_read) {
+        try {
+          const history = await client.api("conversations.history", {
+            channel: entry.id,
+            oldest: entry.last_read,
+            limit: maxMessages,
+            inclusive: false
+          });
+          let msgs = asArray3(history.messages).filter(isRecord6);
+          if (skipSystem) {
+            msgs = msgs.filter((m) => {
+              const subtype = getString5(m.subtype);
+              if (!subtype) {
+                return true;
+              }
+              const systemSubtypes = [
+                "channel_join",
+                "channel_leave",
+                "channel_topic",
+                "channel_purpose",
+                "channel_name",
+                "channel_archive",
+                "channel_unarchive",
+                "group_join",
+                "group_leave",
+                "group_topic",
+                "group_purpose",
+                "group_name",
+                "group_archive",
+                "group_unarchive"
+              ];
+              return !systemSubtypes.includes(subtype);
+            });
+          }
+          if (entry.unread_count_display === undefined && entry.unread_count === undefined) {
+            unreadCount = msgs.length;
+            if (history.has_more) {
+              unreadCount = Math.max(unreadCount, 2);
+            }
+          }
+          messages = msgs.map((m) => {
+            const rendered = renderSlackMessageContent(m);
+            const content = maxBodyChars >= 0 && rendered.length > maxBodyChars ? `${rendered.slice(0, maxBodyChars)}
+...` : rendered;
+            return {
+              ts: getString5(m.ts) ?? "",
+              author: getString5(m.user) || getString5(m.bot_id) ? {
+                user_id: getString5(m.user) ?? undefined,
+                bot_id: getString5(m.bot_id) ?? undefined
+              } : undefined,
+              content: content || undefined,
+              thread_ts: getString5(m.thread_ts) ?? undefined,
+              reply_count: getNumber4(m.reply_count) ?? undefined
+            };
+          });
+          messages.sort((a, b) => Number.parseFloat(a.ts) - Number.parseFloat(b.ts));
+        } catch {}
+      }
+      return { messages, unreadCount };
+    })();
+    const [channelData, historyData] = await Promise.all([channelInfoPromise, historyPromise]);
+    return {
+      channel_id: entry.id,
+      channel_name: channelData.name,
+      channel_type: channelData.type,
+      unread_count: historyData.unreadCount,
+      mention_count: entry.mention_count ?? 0,
+      messages: historyData.messages
+    };
+  }));
+  channelInfos.sort((a, b) => {
+    if (a.mention_count !== b.mention_count) {
+      return b.mention_count - a.mention_count;
+    }
+    return b.unread_count - a.unread_count;
+  });
+  const threads = isRecord6(resp.threads) ? resp.threads : null;
+  const threadInfo = threads?.has_unreads ? {
+    has_unreads: true,
+    mention_count: threads.mention_count ?? 0
+  } : null;
+  return { channels: channelInfos, threads: threadInfo };
+}
+function isRecord6(value) {
+  return typeof value === "object" && value !== null;
+}
+function asArray3(value) {
+  return Array.isArray(value) ? value : [];
+}
+function getString5(value) {
+  return typeof value === "string" ? value : undefined;
+}
+function getNumber4(value) {
+  return typeof value === "number" ? value : undefined;
+}
+
+// src/cli/unreads-command.ts
+function registerUnreadsCommand(input) {
+  input.program.command("unreads").description("Show all unread messages across channels, DMs, and threads").option("--workspace <url>", "Workspace URL (defaults to your configured workspace)").option("--counts-only", "Only show unread counts, do not fetch message content").option("--max-messages <n>", "Max unread messages to fetch per channel (default 10)", "10").option("--max-body-chars <n>", "Max content characters per message (default 4000, -1 for unlimited)", "4000").option("--include-system", "Include system messages (joins, leaves, topic changes, etc.)").action(async (options) => {
+    try {
+      const workspaceUrl = input.ctx.effectiveWorkspaceUrl(options.workspace);
+      const payload = await input.ctx.withAutoRefresh({
+        workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+          return fetchUnreads(client, {
+            includeMessages: !options.countsOnly,
+            maxMessagesPerChannel: Number.parseInt(options.maxMessages ?? "10", 10),
+            maxBodyChars: Number.parseInt(options.maxBodyChars ?? "4000", 10),
+            skipSystemMessages: !options.includeSystem
+          });
+        }
+      });
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+}
+
 // src/lib/update.ts
 import { execSync as execSync2 } from "node:child_process";
 import { createHash } from "node:crypto";
@@ -7921,6 +8519,274 @@ function registerChannelCommand(input) {
   });
 }
 
+// src/slack/workflows.ts
+async function listChannelWorkflows(client, channelId) {
+  const [bookmarked, featured] = await Promise.all([
+    listBookmarkedWorkflows(client, channelId),
+    listFeaturedWorkflows(client, channelId)
+  ]);
+  const featuredIds = new Set(featured.map((f) => f.trigger_id));
+  const seen = new Set;
+  const workflows = [];
+  for (const bk of bookmarked) {
+    if (bk.trigger_id) {
+      seen.add(bk.trigger_id);
+    }
+    workflows.push({
+      title: bk.title,
+      trigger_id: bk.trigger_id ?? "",
+      link: bk.link,
+      app_id: bk.app_id,
+      featured: bk.trigger_id ? featuredIds.has(bk.trigger_id) : false
+    });
+  }
+  for (const ft of featured) {
+    if (!seen.has(ft.trigger_id)) {
+      workflows.push({
+        title: ft.title,
+        trigger_id: ft.trigger_id,
+        featured: true
+      });
+    }
+  }
+  return { channel_id: channelId, workflows };
+}
+async function listBookmarkedWorkflows(client, channelId) {
+  const resp = await client.api("bookmarks.list", {
+    channel_id: channelId
+  });
+  return asArray(resp.bookmarks).filter(isRecord).filter((b) => {
+    const link = getString(b.link) ?? "";
+    const shortcutId = getString(b.shortcut_id);
+    return shortcutId || link.includes("slack.com/shortcuts/");
+  }).map((b) => {
+    const link = getString(b.link);
+    const shortcutId = getString(b.shortcut_id);
+    const triggerId = shortcutId || extractTriggerId(link);
+    return {
+      title: getString(b.title) ?? "",
+      trigger_id: triggerId,
+      link,
+      app_id: getString(b.app_id)
+    };
+  });
+}
+async function listFeaturedWorkflows(client, channelId) {
+  try {
+    const resp = await client.api("workflows.featured.list", {
+      channel_ids: JSON.stringify([channelId])
+    });
+    const entries = asArray(resp.featured_workflows).filter(isRecord);
+    const entry = entries.find((e) => getString(e.channel_id) === channelId);
+    if (!entry) {
+      return [];
+    }
+    return asArray(entry.triggers).filter(isRecord).map((t) => ({
+      trigger_id: getString(t.id) ?? "",
+      title: getString(t.title) ?? ""
+    })).filter((t) => t.trigger_id);
+  } catch {
+    return [];
+  }
+}
+async function previewWorkflow(client, triggerId) {
+  const resp = await client.api("workflows.triggers.preview", {
+    trigger_ids: triggerId
+  });
+  const triggers = asArray(resp.triggers).filter(isRecord);
+  if (triggers.length === 0) {
+    const rejected = asArray(resp.rejected_triggers);
+    if (rejected.length > 0) {
+      throw new Error(`Trigger ${triggerId} was rejected — you may not have access`);
+    }
+    throw new Error(`No preview data returned for trigger ${triggerId}`);
+  }
+  const t = triggers[0];
+  const wf = isRecord(t.workflow) ? t.workflow : {};
+  const wfApp = isRecord(wf.app) ? wf.app : {};
+  const details = isRecord(t.workflow_details) ? t.workflow_details : {};
+  return {
+    trigger_id: getString(t.id) ?? triggerId,
+    type: getString(t.type) ?? "",
+    name: getString(t.name) ?? "",
+    description: getString(t.description) ?? "",
+    shortcut_url: getString(t.shortcut_url),
+    workflow: {
+      id: getString(wf.workflow_id) ?? "",
+      title: getString(wf.title) ?? "",
+      description: getString(wf.description) ?? "",
+      app_id: getString(wf.app_id) ?? getString(wfApp.id) ?? "",
+      app_name: getString(wfApp.name) ?? ""
+    },
+    collaborators: asArray(details.collaborators).map((c) => typeof c === "string" ? c : "").filter(Boolean)
+  };
+}
+async function runWorkflow(client, input) {
+  const clientToken = `cli-${Date.now()}`;
+  const resp = await client.api("workflows.triggers.trip", {
+    url: input.shortcutUrl,
+    client_token: clientToken,
+    context: JSON.stringify({
+      location: "bookmark",
+      channel_id: input.channelId,
+      trigger_id: input.triggerId
+    }),
+    run_precheck: true
+  });
+  return {
+    function_execution_id: getString(resp.function_execution_id) ?? "",
+    trigger_execution_id: getString(resp.trigger_execution_id) ?? "",
+    is_slow_workflow: resp.is_slow_workflow === true
+  };
+}
+async function resolveShortcutUrl(client, input) {
+  const { channelId, triggerId } = input;
+  const resp = await client.api("bookmarks.list", {
+    channel_id: channelId
+  });
+  const bookmarks = asArray(resp.bookmarks).filter(isRecord);
+  for (const b of bookmarks) {
+    const shortcutId = getString(b.shortcut_id);
+    if (shortcutId === triggerId) {
+      const link = getString(b.link);
+      if (link) {
+        return link;
+      }
+    }
+  }
+  throw new Error(`Could not find shortcut URL for trigger ${triggerId} in channel bookmarks`);
+}
+async function getWorkflowSchema(client, workflowId) {
+  const resp = await client.api("workflows.get", { workflow_id: workflowId });
+  const wf = isRecord(resp.workflow) ? resp.workflow : null;
+  if (!wf) {
+    throw new Error(`No workflow found for ID ${workflowId}`);
+  }
+  const steps = asArray(wf.steps).filter(isRecord);
+  const stepSummaries = [];
+  let fields = [];
+  let formTitle;
+  for (const step of steps) {
+    const fn = isRecord(step.function) ? step.function : {};
+    const callbackId = getString(fn.callback_id) ?? "";
+    const title = getString(fn.title) ?? callbackId;
+    stepSummaries.push(title);
+    if (callbackId === "open_form") {
+      const inputs = isRecord(step.inputs) ? step.inputs : {};
+      const titleInput = isRecord(inputs.title) ? inputs.title : {};
+      formTitle = getString(titleInput.value);
+      const fieldsInput = isRecord(inputs.fields) ? inputs.fields : {};
+      const fieldsValue = isRecord(fieldsInput.value) ? fieldsInput.value : {};
+      const elements = asArray(fieldsValue.elements).filter(isRecord);
+      const required = new Set(asArray(fieldsValue.required).map((r) => typeof r === "string" ? r : "").filter(Boolean));
+      fields = elements.map((el) => ({
+        name: getString(el.name) ?? "",
+        title: getString(el.title) ?? "",
+        type: getString(el.type) ?? "string",
+        description: getString(el.description) ?? "",
+        required: required.has(getString(el.name) ?? ""),
+        long: el.long === true ? true : undefined
+      }));
+    }
+  }
+  return {
+    workflow_id: getString(wf.id) ?? workflowId,
+    title: getString(wf.title) ?? "",
+    description: getString(wf.description) ?? "",
+    form_title: formTitle,
+    fields,
+    steps: stepSummaries
+  };
+}
+function extractTriggerId(link) {
+  if (!link) {
+    return;
+  }
+  const match = link.match(/slack\.com\/shortcuts\/(Ft[A-Za-z0-9]+)/);
+  return match?.[1];
+}
+
+// src/cli/workflow-command.ts
+function registerWorkflowCommand(input) {
+  const workflowCmd = input.program.command("workflow").description("Discover and interact with Slack workflows");
+  workflowCmd.command("list").description("List workflows bookmarked or featured in a channel").argument("<channel>", "Channel id or name (#channel, channel, C...)").option("--workspace <url>", "Workspace selector (full URL or unique substring; required if you have multiple workspaces)").action(async (...args) => {
+    const [channel, options] = args;
+    try {
+      const workspaceUrl = input.ctx.effectiveWorkspaceUrl(options.workspace);
+      const payload = await input.ctx.withAutoRefresh({
+        workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+          const channelId = await resolveChannelId(client, channel);
+          return await listChannelWorkflows(client, channelId);
+        }
+      });
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  workflowCmd.command("preview").description("Get workflow metadata from a trigger ID (no side effects)").argument("<trigger-id>", "Trigger ID (Ft...)").option("--workspace <url>", "Workspace selector (full URL or unique substring; required if you have multiple workspaces)").action(async (...args) => {
+    const [triggerId, options] = args;
+    try {
+      const workspaceUrl = input.ctx.effectiveWorkspaceUrl(options.workspace);
+      const payload = await input.ctx.withAutoRefresh({
+        workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+          return await previewWorkflow(client, triggerId);
+        }
+      });
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  workflowCmd.command("get").description("Get workflow definition including form fields and steps (accepts Ft... or Wf...)").argument("<id>", "Trigger ID (Ft...) or Workflow ID (Wf...)").option("--workspace <url>", "Workspace selector (full URL or unique substring; required if you have multiple workspaces)").action(async (...args) => {
+    const [id, options] = args;
+    try {
+      const workspaceUrl = input.ctx.effectiveWorkspaceUrl(options.workspace);
+      const payload = await input.ctx.withAutoRefresh({
+        workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+          let workflowId = id;
+          if (id.startsWith("Ft")) {
+            const preview = await previewWorkflow(client, id);
+            workflowId = preview.workflow.id;
+          }
+          return await getWorkflowSchema(client, workflowId);
+        }
+      });
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+  workflowCmd.command("run").description("Trip a workflow trigger").argument("<trigger-id>", "Trigger ID (Ft...)").requiredOption("--channel <id-or-name>", "Channel where the workflow is bookmarked").option("--workspace <url>", "Workspace selector (full URL or unique substring; required if you have multiple workspaces)").action(async (...args) => {
+    const [triggerId, options] = args;
+    try {
+      const workspaceUrl = input.ctx.effectiveWorkspaceUrl(options.workspace);
+      const payload = await input.ctx.withAutoRefresh({
+        workspaceUrl,
+        work: async () => {
+          const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+          const channelId = await resolveChannelId(client, options.channel);
+          const shortcutUrl = await resolveShortcutUrl(client, { channelId, triggerId });
+          return await runWorkflow(client, { shortcutUrl, channelId, triggerId });
+        }
+      });
+      console.log(JSON.stringify(pruneEmpty(payload), null, 2));
+    } catch (err) {
+      console.error(input.ctx.errorMessage(err));
+      process.exitCode = 1;
+    }
+  });
+}
+
 // src/index.ts
 var program = new Command;
 program.name("agent-slack").description("Slack automation CLI for AI agents").version(getPackageVersion());
@@ -7929,9 +8795,12 @@ registerAuthCommand({ program, ctx });
 registerMessageCommand({ program, ctx });
 registerCanvasCommand({ program, ctx });
 registerSearchCommand({ program, ctx });
+registerLaterCommand({ program, ctx });
+registerUnreadsCommand({ program, ctx });
 registerUpdateCommand({ program });
 registerUserCommand({ program, ctx });
 registerChannelCommand({ program, ctx });
+registerWorkflowCommand({ program, ctx });
 program.parse(process.argv);
 if (!process.argv.slice(2).length) {
   program.outputHelp();
@@ -7941,5 +8810,5 @@ if (subcommand && subcommand !== "update") {
   backgroundUpdateCheck();
 }
 
-//# debugId=3EBC31FAC3ADA2FD64756E2164756E21
+//# debugId=517A87768FFFD43D64756E2164756E21
 //# sourceMappingURL=index.js.map