agent-slack 0.8.5 → 0.9.0

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) {
@@ -4590,14 +4600,15 @@ async function sendMessage(input) {
   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,
           blocks,
@@ -4606,17 +4617,17 @@ async function sendMessage(input) {
         });
       }
     });
-    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,
           blocks,
@@ -4624,20 +4635,20 @@ async function sendMessage(input) {
         });
       }
     });
-    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,
         blocks,
@@ -4646,7 +4657,6 @@ async function sendMessage(input) {
       });
     }
   });
-  return { ok: true };
 }
 function normalizeAttachPaths(raw) {
   if (!Array.isArray(raw) || raw.length === 0) {
@@ -4662,13 +4672,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 +4709,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));
@@ -9156,5 +9185,5 @@ if (subcommand && subcommand !== "update") {
   backgroundUpdateCheck();
 }
 
-//# debugId=DD5B850D326A863A64756E2164756E21
+//# debugId=5E5A3A0EB875DD7164756E2164756E21
 //# sourceMappingURL=index.js.map