Skip to content
Back to search

agent-slack

Slack automation CLI for AI agents

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/stablyai-agent-slack/badge.svg)](/listings/stablyai-agent-slack)

HTML

<a href="/listings/stablyai-agent-slack"><img src="/api/listings/stablyai-agent-slack/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

Install via Bun (recommended):

curl -fsSL https://raw.githubusercontent.com/stablyai/agent-slack/main/install.sh | sh

OR npm global install (requires Node >= 22.5):

npm i -g agent-slack

OR run via Nix flake:

nix run github:stablyai/agent-slack

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 614 lines · 1 finding marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. # agent-slack
  2. Slack automation CLI for AI agents (TypeScript + Bun).
  3. Guiding principle:
  4. - **Token-efficient** — (compact JSON, minimal duplication, and empty/null fields pruned) so LLMs can consume results cheaply.
  5. - **Zero-config auth** — Auth just works if you have Slack Desktop (with fallbacks available). No Python dependency.
  6. - **Human-in-the-loop** — When appropriate (not in CI environments), loop humans in. Ex: `message compose`
  7. <img width="1228" height="741" alt="image" src="https://github.com/user-attachments/assets/92ecbb71-18ca-4516-a874-c83c154b0709" />
  8. ## Getting started
  9. Install via Bun (recommended):
  10. ```bash
  11. curl -fsSL https://raw.githubusercontent.com/stablyai/agent-slack/main/install.sh | sh
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 17 on GitHub
  12. ```
  13. OR npm global install (requires Node >= 22.5):
  14. ```bash
  15. npm i -g agent-slack
  16. ```
  17. OR run via Nix flake:
  18. ```bash
  19. nix run github:stablyai/agent-slack
  20. ```
  21. ## At a glance
  22. - **Read**: fetch a message, browse channel history, list full threads
  23. - **Search**: messages + files (with filters)
  24. - **Artifacts**: auto-download snippets/images/files to local paths for agents
  25. - **Write**: send now or schedule delivery, edit/delete messages, add reactions (bullet lists auto-render as native Slack rich text)
  26. - **Compose & drafts**: open a browser editor (`message compose`), or manage Slack-native drafts that show up in your Slack client (`message draft`)
  27. - **Channels**: list conversations, create channels, and invite users by id/handle/email
  28. - **Canvas**: create, edit, and fetch Slack canvases as Markdown
  29. ## Agent skill
  30. This repo ships an agent skill at `skills/agent-slack/` compatible with Claude Code, Codex, Cursor, etc
  31. Treat the installed CLI's `agent-slack --help` and `agent-slack <command> --help` output as authoritative for supported commands and flags.
  32. **Install via [skills.sh](https://skills.sh)** (recommended):
  33. ```bash
  34. npx skills add stablyai/agent-slack
  35. ```
  36. <details>
  37. <summary>Manual installation</summary>
  38. ```bash
  39. bash ./scripts/install-skill.sh
  40. ```
  41. </details>
  42. ## Command map (high level)
  43. ```text
  44. agent-slack
  45. ├── update # self-update (detects npm/bun/binary)
  46. ├── auth
  47. │ ├── whoami
  48. │ ├── test
  49. │ ├── import-desktop
  50. │ ├── import-brave
  51. │ ├── import-chrome
  52. │ ├── import-firefox
  53. │ └── parse-curl
  54. ├── message
  55. │ ├── get <target> # fetch 1 message (+ thread meta )
  56. │ ├── list <target> # fetch thread or recent channel messages
  57. │ ├── send <target> [text] # send / reply / schedule (supports --attach, --blocks)
  58. │ ├── scheduled
  59. │ │ ├── list # list pending scheduled messages
  60. │ │ └── cancel <id> # cancel a pending scheduled message
  61. │ ├── compose <target> [text] # open Slack-like editor in browser
  62. │ ├── draft # Slack-native drafts (appear in your Slack client)
  63. │ │ ├── list # list Slack-native drafts
  64. │ │ ├── create <target> <text> # create a Slack-native draft (supports --attach)
  65. │ │ ├── update <id> <text> # replace a draft's text (supports --attach)
  66. │ │ └── delete <id> # delete a draft
  67. │ ├── edit <target> <text> # edit a message
  68. │ ├── delete <target> # delete a message
  69. │ └── react
  70. │ ├── add <target> <emoji>
  71. │ └── remove <target> <emoji>
  72. ├── channel
  73. │ ├── list # list conversations (user-scoped or all)
  74. │ ├── new # create channel
  75. │ └── invite # invite users to channel
  76. ├── user
  77. │ ├── list
  78. │ └── get <user>
  79. ├── search
  80. │ ├── all <query> # messages + files
  81. │ ├── messages <query>
  82. │ └── files <query>
  83. ├── workflow
  84. │ ├── list <channel> # workflows bookmarked in a channel
  85. │ ├── preview <trigger-id> # trigger metadata (no side effects)
  86. │ ├── get <id> # workflow definition + form fields
  87. │ └── run <trigger-id> # trip a workflow trigger
  88. └── canvas
  89. ├── create # markdown file/blob → canvas
  90. ├── edit <canvas-url-or-id> # replace/insert/delete/rename a canvas
  91. └── get <canvas-url-or-id> # canvas → markdown
  92. ```
  93. Notes:
  94. - Slack data commands output aggressively pruned JSON (`null`/empty fields removed); help, update, and some authentication setup commands output text.
  95. - Attached files are auto-downloaded and returned as absolute local paths.
  96. ## Authentication (no fancy setup)
  97. On macOS and Windows, authentication happens automatically:
  98. - Default: reads Slack Desktop local data (no need to quit Slack)
  99. - Fallbacks: if that fails, tries Chrome/Brave/Firefox extraction (macOS)
  100. You can also run manual imports:
  101. ```bash
  102. agent-slack auth whoami
  103. agent-slack auth import-desktop
  104. agent-slack auth import-brave
  105. agent-slack auth import-chrome
  106. agent-slack auth import-firefox
  107. agent-slack auth test
  108. ```
  109. > [!NOTE]
  110. > `import-brave` / `import-chrome` read tokens from a logged-in Slack tab via AppleScript. Both browsers ship with **Allow JavaScript from Apple Events** disabled by default — enable it in **View → Developer** before running these commands. macOS will prompt for your password the first time.
  111. Alternatively, set env vars:
  112. ```bash
  113. export SLACK_TOKEN="xoxc-..." # browser token
  114. export SLACK_COOKIE_D="xoxd-..." # cookie d
  115. agent-slack auth test
  116. ```
  117. Or use a standard Slack token (xoxb/xoxp):
  118. ```bash
  119. export SLACK_TOKEN="xoxb-..."
  120. agent-slack auth test
  121. ```
  122. ## Targets: URL or channel
  123. `message get` / `message list` accept either a Slack message URL or a channel reference:
  124. - URL: `https://workspace.slack.com/archives/<channel>/p<digits>[?thread_ts=...]`
  125. - Channel: `#general` (or bare `general`) or a channel ID like `C0123...`
  126. In practice:
  127. ```bash
  128. # Get a single message by channel + ts
  129. agent-slack message get "#general" --ts "1770165109.628379"
  130. # List a full thread by channel + thread root ts
  131. agent-slack message list "#general" --thread-ts "1770165109.000001"
  132. ```
  133. If you have multiple workspaces configured and you use a channel **name** (`#channel` / `channel`), you must pass `--workspace` (or set `SLACK_WORKSPACE_URL`).
  134. `--workspace` accepts a full URL or a unique substring selector:
  135. ```bash
  136. agent-slack message get "#general" --workspace "https://stablygroup.slack.com" --ts "1770165109.628379"
  137. agent-slack message get "#general" --workspace "stablygroup" --ts "1770165109.628379"
  138. ```
  139. ## Examples
  140. > [!TIP]
  141. > You should probably just use the skill for your agent instead of reading below.
  142. ### Read messages / threads
  143. ```bash
  144. # Single message (+ thread summary if threaded)
  145. agent-slack message get "https://workspace.slack.com/archives/C123/p1700000000000000"
  146. # Full thread for a message
  147. agent-slack message list "https://workspace.slack.com/archives/C123/p1700000000000000"
  148. # Recent channel messages (browse channel history)
  149. agent-slack message list "#general" --limit 20
  150. # Recent channel messages that are marked with :eyes:
  151. agent-slack message list "#general" --with-reaction eyes --oldest "1770165109.000000" --limit 20
  152. # Recent channel messages that do not have :dart:
  153. agent-slack message list "#general" --without-reaction dart --oldest "1770165109.000000" --limit 20
  154. ```
  155. Optional:
  156. ```bash
  157. # Include reactions + which users reacted
  158. agent-slack message get "https://workspace.slack.com/archives/C123/p1700000000000000" --include-reactions
  159. ```
  160. ### Compose a message (browser editor)
  161. Opens a Slack-like WYSIWYG editor in your browser for composing messages with full formatting support (bold, italic, strikethrough, links, lists, quotes, code, code blocks).
  162. ```bash
  163. # Open editor for a channel
  164. agent-slack message compose "#general"
  165. # Open editor with initial text
  166. agent-slack message compose "#general" "Here's my update"
  167. # Open the editor and suppress link/media previews when sent
  168. agent-slack message compose "#general" "Release notes: https://example.com" --no-unfurl
  169. # Reply in a thread
  170. agent-slack message compose "https://workspace.slack.com/archives/C123/p1700000000000000"
  171. ```
  172. After sending, the editor shows a "View in Slack" link to the posted message.
  173. `message compose` is send-capable. In CI, it skips the browser editor and immediately sends supplied text; do not use it for a compose-only request in a noninteractive environment.
  174. ### Slack-native drafts
  175. Manage drafts through Slack's own drafts API, so they show up natively in the user's Slack client (mobile and desktop) ready to review and send. Requires browser-style auth (xoxc/xoxd).
  176. > [!NOTE]
  177. > These commands use Slack's **undocumented** internal `drafts.*` client endpoints (the same ones the Slack app uses), authenticated with your own browser session. They act only as you, on your own drafts — nothing is exposed that you can't already see, and `create` posts nothing. But because the endpoints are unsupported: their behavior may change without notice, and on **Enterprise Grid** this style of session-token API use can be flagged by Slack's security/anomaly detection. This is the same auth model the rest of agent-slack already uses (`later`, `unreads`, `search`); use it where that's acceptable.
  178. ```bash
  179. # List unsent drafts
  180. agent-slack message draft list
  181. # Draft a message to a channel (shows up in Slack's Drafts section)
  182. agent-slack message draft create "#general" "Here's my update"
  183. # Draft a thread reply
  184. agent-slack message draft create "https://workspace.slack.com/archives/C123/p1700000000000000" "Looking into it"
  185. # Replace a draft's text, or delete it
  186. agent-slack message draft update "DR_ID" "Here's my revised update"
  187. agent-slack message draft delete "DR_ID"
  188. # Attach local files to a draft (repeatable). On update, new files are
  189. # added to the draft's existing attachments rather than replacing them.
  190. agent-slack message draft create "#general" "Latest numbers" --attach ./q3.png --attach ./q3.csv
  191. agent-slack message draft update "DR_ID" "Latest numbers" --attach ./appendix.pdf
  192. ```
  193. ### Safe mode (enforced human-in-the-loop)
  194. Skill instructions like "always use `draft`, never `send`" are guidance an agent can ignore. Safe mode enforces it at the tool level — useful when an AI agent has access to `agent-slack` and you want a guarantee that nothing posts without human review.
  195. ```bash
  196. # Env var (recommended for agent environments)
  197. export AGENT_SLACK_SAFE_MODE=1
  198. # Or a global CLI flag
  199. agent-slack --safe-mode message send "#general" "hello"
  200. ```
  201. While safe mode is active:
  202. - `message send` → redirected to the draft editor with the text pre-filled; you review and send from the browser. The output includes `"safe_mode": true` and `"redirected_from": "send"`, and a warning is printed to stderr. Flags the editor cannot represent (`--attach`, `--blocks`, `--schedule`, `--schedule-in`, `--reply-broadcast`) are rejected with an error instead of being silently dropped.
  203. - `message edit` and `message delete` → blocked with an error.
  204. - All read operations (`get`, `list`, `search`, etc.) and reactions are unchanged.
  205. The env var accepts `1`, `true`, `yes`, or `on` (case-insensitive); anything else leaves safe mode off.
  206. ### Reply, edit, delete, and react
  207. ```bash
  208. agent-slack message send "https://workspace.slack.com/archives/C123/p1700000000000000" "I can take this."
  209. agent-slack message send "#alerts-staging" "here's the report" --attach ./report.md
  210. agent-slack message send "#announcements" "Deploy starts at 6pm." --schedule "<future-iso-with-timezone>"
  211. agent-slack message send "U05BRPTKL6A" "Heads up before standup" --schedule-in "monday 9am"
  212. agent-slack message edit "https://workspace.slack.com/archives/C123/p1700000000000000" "I can take this today."
  213. agent-slack message delete "https://workspace.slack.com/archives/C123/p1700000000000000"
  214. agent-slack message react add "https://workspace.slack.com/archives/C123/p1700000000000000" "eyes"
  215. agent-slack message react remove "https://workspace.slack.com/archives/C123/p1700000000000000" "eyes"
  216. ```
  217. Channel mode requires `--ts`:
  218. ```bash
  219. agent-slack message edit "#general" "Updated text" --workspace "myteam" --ts "1770165109.628379"
  220. agent-slack message delete "#general" --workspace "myteam" --ts "1770165109.628379"
  221. ```
  222. `message edit` and ordinary `message send` calls convert bullet/numbered lists to Slack native rich text. `message send --blocks` uses the supplied blocks instead, while `message send --attach` sends its initial comment as plain text without automatic list conversion. Inside auto-converted lists, inline mentions, broadcasts, emoji shortcodes, `<#C...>` channel references, and Slack manual links such as `<https://example.com/pull/42|PR #42>` are preserved as Slack elements. CommonMark links such as `[PR #42](https://example.com/pull/42)` are not converted into labeled link elements.
  223. Send options for `message send`:
  224. - `--attach <path>` upload a local file (repeatable; `<text>` is optional when attaching files)
  225. - `--blocks <path>` send raw [Block Kit](https://docs.slack.dev/block-kit/) blocks from a JSON file (or `-` for stdin). Bypasses the automatic markdown-to-rich-text conversion, unlocking header/divider/section/table blocks and other structured layouts. Cannot be combined with `--attach`.
  226. - `--reply-broadcast` when replying in a thread, also post the reply to the parent channel (Slack's "Also send to #channel" checkbox). For channel targets, pair with `--thread-ts`; for URL targets, the thread context is derived from the message. Not supported for DM targets; cannot be combined with `--attach`.
  227. - `--no-unfurl` suppress Slack link and media previews. Also available on `message compose`; cannot be combined with `--attach`.
  228. - `--schedule <time>` schedule delivery at an ISO 8601 timestamp with explicit timezone (for example `YYYY-MM-DDTHH:mm:ss-07:00`) or a Unix timestamp. The timestamp must be in the future and within Slack's 120-day scheduled-send limit. Works with `--blocks`, `--thread-ts`, `--reply-broadcast`, and `--no-unfurl`; cannot be combined with `--attach`.
  229. - `--schedule-in <duration>` schedule delivery after a duration or simple future phrase (`30m`, `3h`, `2d`, `tomorrow 9am`, `monday 9am`; phrases use your local timezone). Mutually exclusive with `--schedule`; cannot be combined with `--attach`.
  230. Upload files through `message send`:
  231. ```bash
  232. agent-slack message send "#general" "Coverage report" --attach ./report.md
  233. ```
  234. Broadcast a thread reply to the parent channel:
  235. ```bash
  236. agent-slack message send "#general" "Decision: shipping v2 today" \
  237. --thread-ts "1770160000.000001" --reply-broadcast
  238. ```
  239. Scheduled sends use Slack's server-side scheduled message queue:
  240. ```bash
  241. # Absolute time with explicit timezone; replace with a future value within 120 days
  242. agent-slack message send "#general" "Reminder: deploy starts soon." \
  243. --schedule "<future-iso-with-timezone>"
  244. # Relative / natural future time
  245. agent-slack message send "#general" "Monday launch checklist" --schedule-in "monday 9am"
  246. # Scheduled thread reply with a Block Kit payload
  247. agent-slack message send "#general" "fallback text" \
  248. --thread-ts "1770160000.000001" --blocks /tmp/blocks.json --schedule-in "3h"
  249. ```
  250. Manage pending scheduled messages:
  251. ```bash
  252. agent-slack message scheduled list
  253. agent-slack message scheduled list --channel "#general" --limit 25
  254. agent-slack message scheduled cancel "Q1234ABCD" --channel "C12345678"
  255. ```
  256. Example — post a message with a native Slack table block:
  257. ```bash
  258. cat > /tmp/blocks.json <<'EOF'
  259. [
  260. {
  261. "type": "header",
  262. "text": { "type": "plain_text", "text": "Weekly digest" }
  263. },
  264. {
  265. "type": "table",
  266. "rows": [
  267. [
  268. { "type": "raw_text", "text": "Name" },
  269. { "type": "raw_text", "text": "Why" }
  270. ],
  271. [
  272. { "type": "raw_text", "text": "Caveman MCP" },
  273. { "type": "raw_text", "text": "~80% token cut on nav" }
  274. ]
  275. ]
  276. }
  277. ]
  278. EOF
  279. agent-slack message send "#alerts-staging" --blocks /tmp/blocks.json
  280. ```
  281. When `--blocks` is used, the positional `<text>` argument (if provided) is still sent as the message's `text` fallback (for notifications and unfurls).
  282. `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. Scheduled sends return `scheduled_message_id` and `post_at` instead of `ts`/`permalink`.
  283. ### List, create, and invite channels
  284. ```bash
  285. # List conversations for current user (users.conversations)
  286. agent-slack channel list
  287. # List conversations for a specific user
  288. agent-slack channel list --user "@alice" --limit 50
  289. # List all workspace conversations (conversations.list)
  290. agent-slack channel list --all --limit 100
  291. # Create a public channel
  292. agent-slack channel new --name "incident-war-room"
  293. # Create a private channel
  294. agent-slack channel new --name "incident-leads" --private
  295. # Invite users by id, handle, or email
  296. agent-slack channel invite --channel "incident-war-room" --users "U01234567,@alice,bob@example.com"
  297. # Invite external Slack Connect users by email (restricted by default)
  298. agent-slack channel invite --channel "incident-war-room" --users "partner@vendor.com" --external
  299. # External invite with permission for invitees to invite others
  300. agent-slack channel invite --channel "incident-war-room" --users "partner@vendor.com" --external --allow-external-user-invites
  301. ```
  302. Notes:
  303. - `channel list` returns a single page plus `next_cursor`; use `--cursor` to fetch the next page.
  304. - `channel list --all` and `channel list --user` are mutually exclusive.
  305. - `--external` maps to `conversations.inviteShared` and expects email targets.
  306. - External invites default to restricted mode (`external_limited=true`); add `--allow-external-user-invites` to disable that restriction.
  307. - External invites require Slack Connect permissions/scopes in your workspace.
  308. ### Message get vs list
  309. **`message get`** fetches a single message. If the message is in a thread, it also returns thread metadata (reply count, participants) but **not** the full thread contents:
  310. ```json
  311. {
  312. "message": { "ts": "...", "text": "...", "user": "U123", ... },
  313. "thread": { "ts": "...", "length": 6 }
  314. }
  315. ```
  316. **`message list`** fetches the thread root plus all replies, or recent channel messages when no thread is specified. Use this when you need the full conversation:
  317. ```json
  318. {
  319. "messages": [
  320. { "ts": "...", "text": "...", "user": "U123", ... },
  321. { "ts": "...", "text": "...", "user": "U456", ... }
  322. ]
  323. }
  324. ```
  325. When to use which:
  326. - Use `get` to check a single message or see if there's a thread worth expanding
  327. - Use `list` to read an entire thread conversation
  328. - Use `list` on a channel (without `--thread-ts`) to browse recent channel messages
  329. - Use `list` with `--with-reaction` / `--without-reaction` plus `--oldest` to filter channel history by reaction markers
  330. ### Files (snippets/images/attachments)
  331. `message get/list` auto-download attached files to an agent-friendly temp directory and return file metadata in `message.files[]`, including `name` when Slack provides the original filename and `path` for the local download. Failed downloads keep the attachment entry, preserve `message.files[].path` with a local `.download-error.txt` file, and include `message.files[].error`. `search messages` and `search all` use the same attachment shape for message results, while `search files` skips entries whose download fails. Use `search messages --content-type file` when you also need the source-message permalink for a reply.
  332. - macOS default: `~/.agent-slack/tmp/downloads/`
  333. Agents can read those paths directly (e.g. snippets as `.txt`, images as `.png`).
  334. ### Search (messages + files)
  335. ```bash
  336. # Search both messages and files
  337. agent-slack search all "smoke tests failed" --channel "#alerts" --after 2026-01-01 --before 2026-02-01
  338. # Search messages only
  339. agent-slack search messages "stably ai" --user "@stablyai" --channel general
  340. # Search files only (downloads files and returns local paths)
  341. agent-slack search files "testing" --content-type snippet --limit 10
  342. ```
  343. Tips:
  344. - For reliable results, include `--channel ...` (channel-scoped search scans history/files and filters locally).
  345. - Use `--workspace <url-or-unique-substring>` when using `#channel` names across multiple workspaces.
  346. <!-- AI search (assistant.search.*) is described in design.doc but not currently implemented. -->
  347. ### Users
  348. Treat Slack user IDs beginning with `U` or `W` equivalently.
  349. ```bash
  350. # List users (email requires appropriate Slack scopes; fields are pruned if missing)
  351. agent-slack user list --workspace "https://workspace.slack.com" --limit 200 | jq .
  352. # Get one user by id or handle
  353. agent-slack user get U12345678 --workspace "https://workspace.slack.com" | jq .
  354. agent-slack user get "@alice" --workspace "https://workspace.slack.com" | jq .
  355. # Open a DM or group DM with one to eight other users (the caller is implicit)
  356. agent-slack user dm-open "@alice" "@bob" --workspace "https://workspace.slack.com" | jq .
  357. ```
  358. ### Unreads (inbox view)
  359. See all unread messages across channels, DMs, and threads in one place:
  360. ```bash
  361. # Show all unreads with message content
  362. agent-slack unreads
  363. # Show only unread counts (no message content)
  364. agent-slack unreads --counts-only
  365. # Limit messages per channel (default 10)
  366. agent-slack unreads --max-messages 5
  367. # Include system messages (joins, leaves, topic changes)
  368. agent-slack unreads --include-system
  369. ```
  370. Output includes channels sorted by mention count, then unread count:
  371. ```json
  372. {
  373. "channels": [
  374. {
  375. "channel_id": "C123...",
  376. "channel_name": "general",
  377. "channel_type": "channel",
  378. "unread_count": 5,
  379. "mention_count": 2,
  380. "messages": [...]
  381. }
  382. ],
  383. "threads": {
  384. "has_unreads": true,
  385. "mention_count": 3
  386. }
  387. }
  388. ```
  389. Note: This feature uses the `client.counts` API which may be restricted in some Enterprise Grid workspaces (`team_is_restricted` error).
  390. ### Later (saved messages)
  391. Manage your saved-for-later messages (Slack's Later tab):
  392. ```bash
  393. # List saved messages (in-progress by default)
  394. agent-slack later list
  395. # Show only counts per state
  396. agent-slack later list --counts-only
  397. # Filter by state: in_progress, completed, archived, all
  398. agent-slack later list --state completed
  399. # Save a message for later
  400. agent-slack later save "https://workspace.slack.com/archives/C123/p1700000000000000"
  401. # Mark as completed
  402. agent-slack later complete "https://workspace.slack.com/archives/C123/p1700000000000000"
  403. # Archive
  404. agent-slack later archive "https://workspace.slack.com/archives/C123/p1700000000000000"
  405. # Move back to in-progress
  406. agent-slack later reopen "https://workspace.slack.com/archives/C123/p1700000000000000"
  407. # Remove from saved
  408. agent-slack later remove "https://workspace.slack.com/archives/C123/p1700000000000000"
  409. # Set a reminder
  410. agent-slack later remind "https://workspace.slack.com/archives/C123/p1700000000000000" --in 1h
  411. agent-slack later remind "https://workspace.slack.com/archives/C123/p1700000000000000" --in tomorrow
  412. ```
  413. Named reminder days such as `tomorrow` and `monday` mean 9:00 in the CLI process's local timezone. Use a Unix timestamp when timezone precision matters.
  414. ### Create, edit, or fetch a Canvas as Markdown
  415. ```bash
  416. # Create from a local Markdown file
  417. agent-slack canvas create --file ./launch-plan.md --title "Launch plan"
  418. # Create from an inline Markdown blob
  419. agent-slack canvas create --markdown $'# Launch plan\n\n- [ ] Ship it' --title "Launch plan"
  420. # Add the new canvas as a channel tab (required on free Slack plans)
  421. agent-slack canvas create --file ./launch-plan.md --channel "project-launch"
  422. # Fetch an existing canvas as Markdown
  423. agent-slack canvas get "https://workspace.slack.com/docs/T123/F456"
  424. agent-slack canvas get "F456" --workspace "https://workspace.slack.com"
  425. # Replace the entire canvas (the default operation)
  426. agent-slack canvas edit "F12345678" --file ./revised-plan.md --workspace "https://workspace.slack.com"
  427. # Apply a section-level edit (look up section IDs with Slack's Canvas tools)
  428. agent-slack canvas edit "F12345678" --operation insert_after --section-id "temp:C:SECTION" \
  429. --markdown $'## Follow-up\n\n- [ ] Verify rollout' --workspace "https://workspace.slack.com"
  430. # Delete a section or rename the canvas
  431. agent-slack canvas edit "F12345678" --operation delete --section-id "temp:C:SECTION" \
  432. --workspace "https://workspace.slack.com"
  433. agent-slack canvas edit "F12345678" --operation rename --title "Launch plan (final)" \
  434. --workspace "https://workspace.slack.com"
  435. ```
  436. `canvas create` requires exactly one of `--file <path>` or `--markdown <text>`. Use
  437. `--workspace <url-or-unique-substring>` to select a workspace when needed. The command returns
  438. `canvas: { id, title?, channel_id? }`. Imported browser credentials can create standalone
  439. canvases; `--channel` requires a standard Slack token with Slack's `canvases:write` scope.
  440. `canvas edit` calls Slack's `canvases.edit` method and supports one operation per call:
  441. `insert_after`, `insert_before`, `insert_at_start`, `insert_at_end`, `replace`, `delete`, or
  442. `rename`. `replace` is the default and replaces the entire canvas unless `--section-id` is
  443. provided. Content operations require exactly one Markdown source; `delete` requires a section ID;
  444. `rename` requires `--title`. Editing requires a standard token with Slack's `canvases:write` scope;
  445. imported browser credentials cannot edit canvases.
  446. ## Developing / Contributing
  447. See [CONTRIBUTING.md](CONTRIBUTING.md).
  448. ## Check out our other OSS project
  449. [Orca](https://github.com/stablyai/orca) - ADE for 100x builders

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.