agent-slack 0.8.5 → 0.9.1

package/README.md

@@ -231,6 +231,8 @@ Attach options for `message send`:
 
 - `--attach <path>` upload a local file (repeatable)
 
+`message send` returns `channel_id` plus the posted `ts` and a `permalink` (for non-attachment sends). `thread_ts` appears only when replying in a thread.
+
 ### List, create, and invite channels
 
 ```bash
@@ -335,6 +337,81 @@ agent-slack user get U12345678 --workspace "https://workspace.slack.com" | jq .
 agent-slack user get "@alice" --workspace "https://workspace.slack.com" | jq .
 ```
 
+### Unreads (inbox view)
+
+See all unread messages across channels, DMs, and threads in one place:
+
+```bash
+# Show all unreads with message content
+agent-slack unreads
+
+# Show only unread counts (no message content)
+agent-slack unreads --counts-only
+
+# Limit messages per channel (default 10)
+agent-slack unreads --max-messages 5
+
+# Include system messages (joins, leaves, topic changes)
+agent-slack unreads --include-system
+```
+
+Output includes channels sorted by mention count, then unread count:
+
+```json
+{
+  "channels": [
+    {
+      "channel_id": "C123...",
+      "channel_name": "general",
+      "channel_type": "channel",
+      "unread_count": 5,
+      "mention_count": 2,
+      "messages": [...]
+    }
+  ],
+  "threads": {
+    "has_unreads": true,
+    "mention_count": 3
+  }
+}
+```
+
+Note: This feature uses the `client.counts` API which may be restricted in some Enterprise Grid workspaces (`team_is_restricted` error).
+
+### Later (saved messages)
+
+Manage your saved-for-later messages (Slack's Later tab):
+
+```bash
+# List saved messages (in-progress by default)
+agent-slack later list
+
+# Show only counts per state
+agent-slack later list --counts-only
+
+# Filter by state: in_progress, completed, archived, all
+agent-slack later list --state completed
+
+# Save a message for later
+agent-slack later save "https://workspace.slack.com/archives/C123/p1700000000000000"
+
+# Mark as completed
+agent-slack later complete "https://workspace.slack.com/archives/C123/p1700000000000000"
+
+# Archive
+agent-slack later archive "https://workspace.slack.com/archives/C123/p1700000000000000"
+
+# Move back to in-progress
+agent-slack later reopen "https://workspace.slack.com/archives/C123/p1700000000000000"
+
+# Remove from saved
+agent-slack later remove "https://workspace.slack.com/archives/C123/p1700000000000000"
+
+# Set a reminder
+agent-slack later remind "https://workspace.slack.com/archives/C123/p1700000000000000" --in 1h
+agent-slack later remind "https://workspace.slack.com/archives/C123/p1700000000000000" --in tomorrow
+```
+
 ### Fetch a Canvas as Markdown
 
 ```bash

package/dist/index.js

@@ -3541,6 +3541,16 @@ function parseSlackMessageUrl(input) {
   const workspace_url = `${url.protocol}//${url.host}`;
   return { workspace_url, channel_id, message_ts, thread_ts_hint, raw: input, possiblyTruncated };
 }
+function buildSlackMessageUrl(input) {
+  const workspaceUrl = input.workspace_url.replace(/\/$/, "");
+  const digits = input.message_ts.replace(".", "");
+  const url = new URL(`${workspaceUrl}/archives/${input.channel_id}/p${digits}`);
+  if (input.thread_ts && input.thread_ts !== input.message_ts) {
+    url.searchParams.set("thread_ts", input.thread_ts);
+    url.searchParams.set("cid", input.channel_id);
+  }
+  return url.toString();
+}
 
 // src/cli/targets.ts
 function parseMsgTarget(input) {
@@ -3579,14 +3589,32 @@ var CODE_BLOCK_START = /^```/;
 var BLOCKQUOTE_RE = /^> (.*)$/;
 function parseInlineElements(text) {
   const elements = [];
-  const re = /`([^`]+)`|\*([^*]+)\*|_([^_]+)_|~([^~]+)~|<([^>|]+)\|([^>]+)>|<([^>|]+)>/g;
+  const re = /`([^`]+)`|\*([^*]+)\*|_([^_]+)_|~([^~]+)~|<@([UWB][A-Z0-9]+)(?:\|[^>]*)?>|<!(here|channel|everyone)(?:\|[^>]*)?>|<([^>|]+)\|([^>]+)>|<([^>|]+)>|(?:^|(?<=[^A-Za-z0-9_]))@([UWB][A-Z0-9]{6,})\b|(?:^|(?<=[^A-Za-z0-9_]))@(here|channel|everyone)\b/g;
   let lastIndex = 0;
   let match;
+  const pushText = (slice) => {
+    if (slice) {
+      elements.push({ type: "text", text: slice });
+    }
+  };
   while ((match = re.exec(text)) !== null) {
     if (match.index > lastIndex) {
-      elements.push({ type: "text", text: text.slice(lastIndex, match.index) });
-    }
-    const [, code, bold, italic, strike, linkUrl, linkText, bareUrl] = match;
+      pushText(text.slice(lastIndex, match.index));
+    }
+    const [
+      ,
+      code,
+      bold,
+      italic,
+      strike,
+      userToken,
+      broadcastToken,
+      linkUrl,
+      linkText,
+      bareUrl,
+      bareUserId,
+      bareBroadcast
+    ] = match;
     if (code != null) {
       elements.push({ type: "text", text: code, style: { code: true } });
     } else if (bold != null) {
@@ -3595,15 +3623,29 @@ function parseInlineElements(text) {
       elements.push({ type: "text", text: italic, style: { italic: true } });
     } else if (strike != null) {
       elements.push({ type: "text", text: strike, style: { strike: true } });
+    } else if (userToken != null) {
+      elements.push({ type: "user", user_id: userToken });
+    } else if (broadcastToken != null) {
+      elements.push({
+        type: "broadcast",
+        range: broadcastToken
+      });
     } else if (linkUrl != null && linkText != null) {
       elements.push({ type: "link", url: linkUrl, text: linkText });
     } else if (bareUrl != null) {
       elements.push({ type: "link", url: bareUrl });
+    } else if (bareUserId != null) {
+      elements.push({ type: "user", user_id: bareUserId });
+    } else if (bareBroadcast != null) {
+      elements.push({
+        type: "broadcast",
+        range: bareBroadcast
+      });
     }
     lastIndex = match.index + match[0].length;
   }
   if (lastIndex < text.length) {
-    elements.push({ type: "text", text: text.slice(lastIndex) });
+    pushText(text.slice(lastIndex));
   }
   return elements.length > 0 ? elements : [{ type: "text", text }];
 }
@@ -3726,6 +3768,23 @@ function collectList(input) {
   return idx;
 }
 
+// src/slack/format-outbound.ts
+function formatOutboundSlackText(text) {
+  if (!text) {
+    return "";
+  }
+  const stash = [];
+  let out = text.replace(/<(?:@[UWB][A-Z0-9]+(?:\|[^>]*)?|#[CG][A-Z0-9]+(?:\|[^>]*)?|![a-zA-Z]+(?:\|[^>]*)?|https?:\/\/[^>]+)>/g, (m) => {
+    stash.push(m);
+    return `\x00${stash.length - 1}\x00`;
+  });
+  out = out.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  out = out.replace(/(^|[^A-Za-z0-9_])@([UWB][A-Z0-9]{6,})\b/g, (_m, pre, id) => `${pre}<@${id}>`);
+  out = out.replace(/(^|[^A-Za-z0-9_])@(here|channel|everyone)\b/g, (_m, pre, name) => `${pre}<!${name}>`);
+  out = out.replace(/\u0000(\d+)\u0000/g, (_m, idx) => stash[Number(idx)]);
+  return out;
+}
+
 // src/slack/upload.ts
 import { readFile as readFile5, stat, realpath } from "node:fs/promises";
 import { basename as basename2 } from "node:path";
@@ -4585,68 +4644,69 @@ function requireOldestWhenReactionFiltersUsed(input) {
 }
 async function sendMessage(input) {
   const target = parseMsgTarget(String(input.targetInput));
+  const formattedText = formatOutboundSlackText(input.text);
   const blocks = input.text ? textToRichTextBlocks(input.text) : null;
   const attachPaths = normalizeAttachPaths(input.options.attach);
   if (target.kind === "url") {
     const { ref } = target;
     warnOnTruncatedSlackUrl(ref);
-    await input.ctx.withAutoRefresh({
+    return await input.ctx.withAutoRefresh({
       workspaceUrl: ref.workspace_url,
       work: async () => {
-        const { client } = await input.ctx.getClientForWorkspace(ref.workspace_url);
+        const { client, workspace_url } = await input.ctx.getClientForWorkspace(ref.workspace_url);
         const msg = await fetchMessage(client, { ref });
         const threadTs = msg.thread_ts ?? msg.ts;
-        await sendMessageToChannel({
+        return await sendMessageToChannel({
           client,
+          workspaceUrl: workspace_url ?? ref.workspace_url,
           channelId: ref.channel_id,
-          text: input.text,
+          text: formattedText,
           blocks,
           threadTs,
           attachPaths
         });
       }
     });
-    return { ok: true };
   }
   if (target.kind === "user") {
     const workspaceUrl2 = input.ctx.effectiveWorkspaceUrl(input.options.workspace);
-    await input.ctx.withAutoRefresh({
+    return await input.ctx.withAutoRefresh({
       workspaceUrl: workspaceUrl2,
       work: async () => {
-        const { client } = await input.ctx.getClientForWorkspace(workspaceUrl2);
+        const { client, workspace_url } = await input.ctx.getClientForWorkspace(workspaceUrl2);
         const dmChannelId = await openDmChannel(client, target.userId);
-        await sendMessageToChannel({
+        return await sendMessageToChannel({
           client,
+          workspaceUrl: workspace_url ?? workspaceUrl2,
           channelId: dmChannelId,
-          text: input.text,
+          text: formattedText,
           blocks,
           attachPaths
         });
       }
     });
-    return { ok: true };
   }
   const workspaceUrl = input.ctx.effectiveWorkspaceUrl(input.options.workspace);
   await input.ctx.assertWorkspaceSpecifiedForChannelNames({
     workspaceUrl,
     channels: [String(target.channel)]
   });
-  await input.ctx.withAutoRefresh({
+  return await input.ctx.withAutoRefresh({
     workspaceUrl,
     work: async () => {
-      const { client } = await input.ctx.getClientForWorkspace(workspaceUrl);
+      const { client, workspace_url } = await input.ctx.getClientForWorkspace(workspaceUrl);
       const channelId = await resolveChannelId(client, String(target.channel));
-      await sendMessageToChannel({
+      return await sendMessageToChannel({
         client,
+        workspaceUrl: workspace_url ?? workspaceUrl,
         channelId,
-        text: input.text,
+        text: formattedText,
         blocks,
         threadTs: input.options.threadTs ? String(input.options.threadTs) : undefined,
         attachPaths
       });
     }
   });
-  return { ok: true };
 }
 function normalizeAttachPaths(raw) {
   if (!Array.isArray(raw) || raw.length === 0) {
@@ -4662,13 +4722,27 @@ function normalizeAttachPaths(raw) {
 }
 async function sendMessageToChannel(input) {
   if (input.attachPaths.length === 0) {
-    await input.client.api("chat.postMessage", {
+    const resp = await input.client.api("chat.postMessage", {
       channel: input.channelId,
       text: input.text,
       thread_ts: input.threadTs,
       ...input.blocks ? { blocks: input.blocks } : {}
     });
-    return;
+    const ts = typeof resp.ts === "string" ? resp.ts : undefined;
+    const channelId = typeof resp.channel === "string" ? resp.channel : input.channelId;
+    const permalink = input.workspaceUrl && ts ? buildSlackMessageUrl({
+      workspace_url: input.workspaceUrl,
+      channel_id: channelId,
+      message_ts: ts,
+      thread_ts: input.threadTs
+    }) : undefined;
+    return {
+      ok: true,
+      channel_id: channelId,
+      ts,
+      thread_ts: input.threadTs,
+      permalink
+    };
   }
   if (input.blocks) {
     process.stderr.write(`Warning: rich text formatting is not supported with file attachments; sending as plain text.
@@ -4685,6 +4759,11 @@ async function sendMessageToChannel(input) {
     });
     initialComment = "";
   }
+  return {
+    ok: true,
+    channel_id: input.channelId,
+    thread_ts: input.threadTs
+  };
 }
 async function editMessage(input) {
   const target = parseMsgTarget(String(input.targetInput));
@@ -4692,6 +4771,7 @@ async function editMessage(input) {
     throw new Error("message edit does not support user ID targets. Use a channel name, channel ID, or message URL.");
   }
   const workspaceUrl = input.ctx.effectiveWorkspaceUrl(input.options.workspace);
+  const formattedText = formatOutboundSlackText(input.text);
   await input.ctx.withAutoRefresh({
     workspaceUrl: target.kind === "url" ? target.ref.workspace_url : workspaceUrl,
     work: async () => {
@@ -4702,7 +4782,7 @@ async function editMessage(input) {
         await client2.api("chat.update", {
           channel: ref.channel_id,
           ts: ref.message_ts,
-          text: input.text
+          text: formattedText
         });
         return;
       }
@@ -4716,7 +4796,7 @@ async function editMessage(input) {
       await client.api("chat.update", {
         channel: channelId,
         ts,
-        text: input.text
+        text: formattedText
       });
     }
   });
@@ -9156,5 +9236,5 @@ if (subcommand && subcommand !== "update") {
   backgroundUpdateCheck();
 }
 
-//# debugId=DD5B850D326A863A64756E2164756E21
+//# debugId=D4BE12D81E739FC964756E2164756E21
 //# sourceMappingURL=index.js.map