CtrlK
BlogDocsLog inGet started
Tessl Logo
PluginPublic

ai-ecoverse/advanced-skills

Quarantined high-risk skills (browser session capture, WebSocket interception) for Slack and Microsoft Teams. Install only after reviewing the security implications.

Quality

96%

Does it follow best practices?

Run evals on this skill

Adds up to 20 points to the overall score

View guide
SecuritybySnyk

Low

Low-risk findings worth noting

Overview
Quality
Evals
Security
Files
name:
slack
description:
Slack Web API client — read and post Slack messages, add or remove emoji reactions, search messages and channels, read threads, look up users by name or email, view the activity feed, and watch channels, running a command for each new message. Multi-workspace, auto-detected from the active tab. Also slack-support for Slack support cases on Salesforce Help (list, view, comment on, open a case through the Fin agent) and intercom for its Intercom chats; slack-ext for admin user management (guests) and app manifest reads and diffs. Use when the user wants to check, post, react to or search Slack messages, watch a channel or thread, or file or follow up a Slack support ticket. Triggers on Slack, channels, DMs, threads, @mentions, reactions, Slackbot, notifications, Slack support, help request, support case, Salesforce Help, Fin, Intercom. Runs in SLICC, and on macOS or Linux under jsh over Chrome DevTools (CDP).
allowed-tools:
bash

Slack

Direct API access to Slack via the browser session. Uses XHR from the Slack page context (same-origin) with the user's xoxc-* token from localStorage. Supports multiple workspaces — the active workspace is auto-detected from the Slack tab URL, or can be specified explicitly with --workspace.

Quick start

# List available workspaces
slack workspaces

# Activity feed (notifications): all, admin-only, unread mentions, app DMs
slack activity
slack --ws=E06V3987PMY activity --type=admin
slack activity --type=mentions --unread
slack activity --type=apps

# Pending approval requests, then approve or deny one by timestamp
slack --ws=E06V3987PMY pending
slack --ws=E06V3987PMY approve 1774846849.585479
slack --ws=E06V3987PMY deny 1770698762.931619

# Read a channel (active workspace), or pick the workspace explicitly
slack history C087NCG774J
slack --workspace=T06DUTYDQ channels --search=helix
slack --ws=T06DUTYDQ history C06ABC123

# Post — prints the new message's ts, auto-signs with :icecream:,
# auto-watches replies for 1h → back to the cone that posted
slack post C087NCG774J "Hello from SLICC!"
slack post C087NCG774J "and part 2" --thread_ts=1787334522.567869   # reply in thread
slack post C087NCG774J "quiet post" --no-sign --no-watch
slack post W5BPKRLUA "Hey, quick question..."   # user ID → DM opened automatically

# Search for channels
slack channels --search=one-aem

# Search message text (not users -- use "slack find" for users)
slack search "deploy failed"
slack search '"AdobeSkills/1.0"' --ws=T06DUTYDQ   # exact phrase

# Read a thread (file/image attachments are shown with their [F...] id)
slack thread C087NCG774J 1774539502.747989

# Download a file shared in a thread (e.g. a screenshot) to view it locally
slack download F0BK6BADTKK --out=/tmp/shot.png

# Upload a file to a channel/DM/thread (optionally with a comment)
slack upload C087NCG774J /tmp/clip.mp3 --thread_ts=1774539502.747989 --comment="voice note"

# Find a user by username (@handle), real name, or email → user ID
slack find tripod
slack find @rofe
slack find "Dragos Dascalita"
slack user W5BPKRLUA

# Watch a channel or a single thread in real time; list watches; stop watching
slack watch C087NCG774J                 # → this cone (needs SLICC_LICK_TARGET)
slack watch C087NCG774J --scoop=my-monitor
slack watch C087NCG774J --scoop=my-monitor --thread=1774539502.747989
slack watches
slack unwatch C087NCG774J

Authentication

The token is extracted automatically from localStorage key localConfig_v2 in the Slack browser tab, whose .teams object maps workspace IDs — enterprise (E...) or team (T...) — to { name, domain, url, token }. All calls execute via XHR from the Slack page context, so cookies are included automatically. This requires an open Slack tab at app.slack.com; without one the script errors and asks the user to open Slack.

Workspace resolution order:

  1. --workspace=<ID> or --ws=<ID> flag if provided
  2. Auto-detected from the active Slack tab URL (/client/<ID>/...)

On a host: jsh over Chrome DevTools

slack and slack-ext also run on macOS or Linux under jsh. They drive a logged-in Slack tab in a Chrome that runs with a DevTools port (SLICC_CDP_URL, default http://127.0.0.1:9222). npm install -g ./skills/slack puts both on PATH. There, slack watch <channel> '<command>' runs a callback for each new message, as ntfy sub does, with the message in $SLACK_TEXT, $SLACK_RAW, etc.:

slack watch C087NCG774J --thread=1774539502.747989 --for=1h \
  'bb thread tell "$BB_THREAD_ID" "Slack reply from $SLACK_USER_NAME: $SLACK_TEXT"'
slack post C087NCG774J "Deploy is out" --watch-command='bb thread tell "$BB_THREAD_ID" "$SLACK_TEXT"'

Install, the callback environment, exit codes and every other difference from SLICC 6: references/jsh-host.md.

Global flags

--workspace=<ID>, --ws=<ID>

Which workspace to use, by team or enterprise ID. slack workspaces lists the available IDs. The flag can appear before or after the command name:

slack --ws=E23RE8G4F history C087NCG774J
slack history C087NCG774J --workspace=E23RE8G4F

Available commands

slack workspaces

List all workspaces the user is signed into. Shows the workspace ID, name, and domain. The currently active workspace (from the tab URL) is marked with *.

slack activity [--type=TYPE] [--unread] [--limit=N] [--cursor=CURSOR]

View the activity feed (notifications). Resolves user and channel names inline. For app DM bundles (invite requests, Google Drive, etc.), fetches the latest messages from the DM channel to show actual content.

Type filters:

  • all (default) — everything
  • admin — system alerts (channel archived, workspace changes)
  • mentions — @user, @usergroup, @channel, @everyone, unjoined channel mentions
  • threads — thread replies
  • reactions — emoji reactions on your messages
  • invites — channel invitations (internal and Slack Connect)
  • apps — bot/app DM bundles (invite requests, Google Drive, etc.)

Flags:

  • --unread — show only unread items
  • --limit=N — number of items (default 20)
  • --cursor=CURSOR — pagination cursor for next page

Output format:

[2026-04-15 16:19:41 UTC] ADMIN: Amol Anand archived the channel #aem-volvo-redesign *
[2026-04-15 15:54:02 UTC] App DM (5 unread): slackbot: Request to join a Slack Connect channel... *
[2026-04-13 16:24:47 UTC] @mention by Stefan Guggisberg in #mpdm-roman-...

Items marked with * are unread.

slack pending [--pages=N] [--json] [--channel=<id>]

List pending approval requests (Slack Connect invites, workspace invites) that have live Approve/Deny action buttons. Pages through the Slackbot DM history, filters out already-processed requests, and shows a formatted table with timestamps you can pass directly to slack approve or slack deny.

Flags:

  • --pages=N — max pages to search (default 10, each page is 100 messages)
  • --json — output raw JSON instead of a table
  • --channel=<id> — override the Slackbot DM channel (auto-detected by default)

slack approve <message_ts> [--channel=<id>]

Click the Approve button on an interactive message (e.g. Slack Connect invite request, workspace invite) via the chat.attachmentAction API. The message_ts is the timestamp of the Slackbot notification message carrying the Approve/Deny buttons. Defaults to the Slackbot DM channel; use --channel to override.

slack deny <message_ts> [--channel=<id>]

Deny an interactive message action. Same as approve but clicks the Deny button.

Approve/deny workflow

Action buttons expire (often within minutes to hours) and expired clicks may silently no-op. Always verify by re-listing pending requests after acting:

# 1. List pending requests — note the timestamp of the target
slack --ws=E06V3987PMY pending
# 2. Approve by timestamp
slack --ws=E06V3987PMY approve 1774846849.585479
# 2b. Or deny by timestamp (use the full command form, not just `deny <ts>`)
slack --ws=E06V3987PMY deny 1770698762.931619
# 3. Verify — the entry should no longer appear in pending
slack --ws=E06V3987PMY pending

If step 3 still shows the same entry, the action button has expired. Re-trigger the request from the original source (e.g. ask the inviter to resend) rather than retrying the same message_ts.

slack history <channel_id> [--limit=N] [--json]

Fetch recent messages from a channel. Default limit is 20.

Authors print as Real Name (@username, ID) whenever Slack returned those fields. User mentions (<@U…> / <@W…>) expand to the same triple; channel mentions (<#C…> / <#C…|name>) expand to #name (C…). Lookups are batched (edge users/info, then users.info) so a long thread does not N+1.

Every line carries the message timestamp as [ts=<ts>] — this is the handle for slack thread <channel> <ts> and for slack post ... --thread_ts=<ts>. The reply count is appended when the message has replies: [ts=1774539502.747989 · 3 replies].

--json prints the raw conversations.history messages array (newest first, exactly as the API returns it) instead of the formatted lines, so jq can consume it:

slack history C087NCG774J --limit=1 --json | jq -r '.[0].ts'
slack history C087NCG774J | grep -o 'ts=[0-9.]*'

slack post <channel_or_user_id> <message>

Post a message to a channel, DM, or user. Accepts channel IDs (C..., D..., G...) directly, or user IDs (U..., W...) — in which case a DM is opened automatically.

slack post C087NCG774J "Hello channel!"
slack post W5BPKRLUA "Hey, quick question..."   # DM, opened automatically
slack post C087NCG774J "Got it" --thread_ts=1774539502.747989   # threaded reply

Output. A successful post prints the new message's timestamp and a ready-to-run reply hint, so a thread can be built without looking the ts up anywhere else:

Message sent to C087NCG774J at 2026-08-21 17:48:42 UTC
Text: Hello channel!
ts: 1787334522.567869
reply with: slack post C087NCG774J "..." --thread_ts=1787334522.567869
Signed with :icecream:

Posting a thread (two steps):

# 1. post the root and capture its ts
ts=$(slack post C087NCG774J "Write-up, part 1 :thread:" | sed -n 's/^ts: //p')

# 2. reply into that thread
slack post C087NCG774J "part 2" --thread_ts="$ts"
slack post C087NCG774J "part 3" --thread_ts=last   # same thread, no bookkeeping

Post flags:

  • --thread_ts=<ts> — post as a threaded reply to the message with that timestamp.
  • --thread_ts=last — reply into the thread of the last message this CLI posted in that channel. Errors if there is none, or if another cone posted it (the error prints its ts). State file and ownership: references/watch-architecture.md, "Shared state across cones".
  • --sign[=<emoji>] / --no-sign — control the auto-sign reaction (see below).
  • --no-watch — skip the auto reply-watch (see below).
  • --watch-scoop=<name> — override the scoop the reply-watch routes to (default: the cone that posted, from SLICC_LICK_TARGET).

Emoji shortcodes in the message are converted to Unicode before sending; a shortcode that resolves to nothing is refused, so the message never posts with a literal :name: in it. Digits between colons inside a time or ratio (09:41:16, 16:9:1) are not treated as shortcodes.

Auto-sign (default-on)

After a successful post the message is signed with an emoji reaction — :icecream: (🍦) by default, via reactions.add. Identical for channel posts, DMs, and threaded replies. Non-fatal: if Slack rejects the reaction (already_reacted, invalid_name, permission errors, etc.) the post still succeeds (exit 0) and a warning goes to stderr.

# Default: signs with :icecream:
slack post C087NCG774J "Deploy is green"        # → "Signed with :icecream:"
# Custom emoji (colons optional — ":robot_face:" or "robot_face" both work)
slack post C087NCG774J "Bot did it" --sign=robot_face
slack post C087NCG774J "Bot did it" --sign :robot_face:
# Opt out entirely
slack post C087NCG774J "no sticker please" --no-sign

Auto-watch for replies, 1 hour (default-on)

After a successful post, replies are watched for one hour and routed back to the cone that posted (--watch-scoop=<name> routes elsewhere, --no-watch opts out); your own messages never notify. Scope, sharing and routing rules: references/watch-architecture.md, "Auto-watch for replies". Under jsh (a host), --watch-command='<cmd>' (or $SLACK_WATCH_COMMAND) runs <cmd> for each reply for an hour, from a background slack watch. Without one, post prints the slack watch command that waits for a reply.

slack react <channel_id> <message_ts> <emoji>

Add an emoji reaction to any message, as you (reactions.add). The emoji is a shortcode with or without colons (:ticket: or ticket; skin tones as +1::skin-tone-3). Use it where a reaction is the trigger, for example a :ticket: reaction that files a vendor ticket in a support channel. The message ts is the [ts=...] that history, thread and search print.

Idempotent: if you already reacted with that emoji, Slack's already_reacted is reported as a note and the command exits 0. Any other Slack error (invalid_name, message_not_found, channel_not_found, ...) prints Error: <error> and exits 1.

slack react C0123456789 1700000000.000100 :ticket:
# → Reacted :ticket: on C0123456789 ts=1700000000.000100
# a second run:
# → Note: C0123456789 ts=1700000000.000100 already has :ticket: from you (already_reacted); nothing to do.

slack unreact <channel_id> <message_ts> <emoji>

Remove your own emoji reaction (reactions.remove). no_reaction (you had not reacted with it) is reported as a note and exits 0; other errors exit 1. Slack only lets you remove your own reactions. Where a reaction triggers a workflow, removing it may undo that workflow (for a :ticket: reaction, cancel the ticket), so check first.

slack reactions <channel_id> <message_ts> [--json]

List the reactions on a message (reactions.get with full=true): one line per emoji with its count and the reacting user ids. --json prints the raw API response.

:ticket:                     1  U0AAAAAAA01
:raised_hands::skin-tone-4:  1  U0BBBBBBB02

slack channels [--search=term]

Search for channels by name. Uses search.modules API (the standard conversations.list is restricted on enterprise grids). Returns channel ID, name, member count, and purpose.

slack search <query> [--limit=N] [--page=N] [--sort=timestamp|score] [--json]

Search message text across the workspace using Slack's search.messages API. Returns matching messages with timestamps, channels, authors, text snippets, and permalinks. Default limit is 20, sorted by timestamp (newest first). Results are scoped to the token's workspace, so --ws=<ID> selects which workspace is searched.

This searches messages. To search users, use slack find. To search channels, use slack channels --search.

Flags:

  • --limit=N -- number of results per page (default 20)
  • --page=N -- page number, 1-based (default 1)
  • --sort=timestamp|score -- sort order (default timestamp)
  • --json -- dump the raw API response

Exact-phrase matching. Slack tokenizes unquoted terms and matches loosely. For example, searching AdobeSkills returned 678 hits because it also matched adobe/skills. Wrapping the term in double quotes makes it an exact phrase: "AdobeSkills/1.0" returned 0 hits. When hunting an exact string, always quote it.

# Search for messages mentioning a topic
slack search "deploy failed"

# Exact phrase -- the double quotes are part of the query
slack search '"AdobeSkills/1.0"' --ws=T06DUTYDQ

# Page through results sorted by relevance
slack search "incident postmortem" --sort=score --page=2

# Raw JSON for scripting
slack search "outage" --limit=5 --json | jq '.messages.matches[].permalink'

slack thread <channel_id> <thread_ts> [--limit=N] [--json]

Read thread replies. Takes the channel ID and the thread's parent timestamp (from slack post output or the [ts=...] in slack history); default limit 50. Human output uses the same author triple and mention/channel expansion as slack history. --json prints the raw conversations.replies messages array instead of the formatted lines. Messages carrying files/images get an extra line per attachment with name, type, dimensions and file id, plus a ready-to-run slack download <file_id> hint.

slack download <file_id> [--out=<path>]

Download a file (e.g. a screenshot shared in a thread) to a local path so you can view it. Get the <file_id> from slack thread / slack history output (shown as [F...]), or pass --url=<url_private> directly. Resolves via files.info, then fetches the bytes authenticated inside the Slack tab (files.slack.com needs the session cookie). Without --out the file lands in /tmp/<original-name>. Under jsh the bytes are fetched from this process with the tab's session cookie; see references/jsh-host.md.

slack upload <channel_id> <file> [--thread_ts=TS] [--comment="..."] [--title="..."]

Upload a local file to a channel, DM, or thread. Accepts a conversation ID or a user ID (U.../W... opens a DM automatically), and uses Slack's 3-step external upload flow (files.getUploadURLExternal → raw bytes → files.completeUploadExternal). --comment becomes the message text, --title the file title, --thread_ts posts it as a threaded reply.

slack upload C087NCG774J /tmp/report.pdf --comment="Q3 numbers"
slack upload C087NCG774J /tmp/voice.mp3 --thread_ts=1774539502.747989 --comment="voice note"

slack find <name, username, or email> [--limit=N]

Search for users by username (@handle, with or without the @), real name, display name, or email and print their user IDs — the fastest way to get an ID for slack post or slack user. Aliases: users, find-user. Default limit is 10.

Each hit prints id, @username, and full/real name, plus title when present:

slack find tripod
#   W4R5LUW5P  Tobias Bocanegra @tripod — Senior Principal Scientist
slack find rofe
#   W4RPXRGKD  Raphael Wegmueller @rofe — Director of Engineering
slack find uncled
#   W4RPL6X6X  David Nuescheler @uncled — Fellow & VP, Developer Platform & Ecosystem
slack find "Dragos Dascalita"
#   W57QU2CLV  Dragos Dascalita Haut @ddascal — Principal Scientist
slack post W57QU2CLV "Hey, quick question..."

A short username like rofe also matches many real names (Robert …) in the edge cache, so handle-shaped queries run both the bare token and @token and rank an exact username match first.

Deactivated and bot accounts are labelled ([deactivated], [bot]) so you can tell duplicates apart. Slack has no users.search method and users.list is restricted on enterprise grids, so this uses the edge users cache (edgeapi.slack.com/cache/<team>/users/search) behind Slack's own quick switcher: cross-origin, but browser.fetch runs in the Slack tab and the shared .slack.com cookie authenticates the xoxc token — no extra auth step. Do not add a users.list crawl.

slack user <user_id>

Look up user information by user ID. Returns name, display name, title, timezone, and status.

slack info <channel_id>

Get channel metadata (name, purpose, topic, member count).

slack slackbot

Opens/finds the Slackbot DM channel and prints its ID.

slack watch <channel_id> [--scoop=<name>] [--thread=<ts>] [--filter=<js>] [--force]

Watch a channel or thread for new messages in real time. Each new message is delivered as a lick event to the target scoop within seconds.

Options:

  • --scoop=<name> — the scoop that receives lick events. Defaults to the calling cone (SLICC_LICK_TARGET); required when that is unset. Why: references/watch-architecture.md, "Routing".
  • --thread=<thread_ts> — watch a specific thread instead of the whole channel
  • --filter=<js> — drop messages before they wake the scoop; event.body is the Slack frame: --filter='(e)=>/deploy failed/i.test(JSON.stringify(e.body))'
  • --force — replace an existing watch on the same target (its webhook and +1h teardown task too)

Lick payload: the raw Slack message frame that matched the filter, e.g.:

{
  "type": "message",
  "channel": "C087NCG774J",
  "thread_ts": null,
  "ts": "1776097845.451319",
  "user": "W5BPKRLUA",
  "text": "Hello world!",
  "subtype": null
}

The watched channel/thread is implicit, and the complete Slack frame is delivered (any additional Slack fields are preserved).

Duplicate prevention: the watch ID is deterministic from channel + thread, so you cannot create two watches on the same target without --force. Watch state is shared by every cone in the workspace, so the refusal names the owning cone and warns when replacing the watch would cut off another cone's replies.

Each watch keeps one SLICC webhook plus a state file at /workspace/skills/slack/.watch-<id>.json. Delivery depends on the Slack tab: if the page reloads, run slack reinject. Internals: references/watch-architecture.md.

slack watch under jsh

slack watch <channel_id> [--thread=<ts>] [--for=<duration>] [--count=N] [--json] [--include-own] [<command>]

On a host (and in SLICC 7), watch runs sh -c '<command>' for each new message, with the message in SLACK_* variables, or prints the messages when there is no command. It ends at --for, at --count (exit 124 if --for comes first), on Ctrl-C, or on slack unwatch. Treat SLACK_* as untrusted and use it quoted. Details: references/jsh-host.md, "Watch with a command".

slack unwatch <channel_id> [--thread=<thread_ts>]

Stop watching a channel or thread. Deletes the webhook (which is what stops delivery), the +1h teardown task if present, and the watch state.

slack watches

List all active Slack watches with their targets, scoops, webhook, and expiry — across every cone in the workspace, with [owner: <cone>] when the owning cone differs from the webhook's scoop.

slack reinject

Re-register the WebSocket observers on the Slack tab for all active watches. Use after a page reload, or if watches stop firing.

slack monday [--limit=N] [--depth=N] [--date=Nd]

Monday protocol: dump the Slack inbox as a single JSON array for triage. Merges unread mentions, unread DMs, and unread thread replies, deduplicates them and sorts newest first. Each item is { id, source, type: mention|dm|thread, title, subtitle, url, ts, body, participants, meta: { channel, thread_ts, msg_ts } }, where body is the thread (or DM tail) fetched to --depth messages. Every source is non-fatal — a failing one is skipped rather than aborting the run.

Flags:

  • --limit=N — items per source, and the cap on the final array (default 50)
  • --depth=N — messages of thread/DM context per item (default 5; 0 skips thread fetching, leaving body empty for mentions and thread items)
  • --date=Nd — how far back to look: Nh, Nd or Nw (default 7d)

Slack support cases (slack-support, intercom)

Slack support moved to Salesforce Help (help.salesforce.com) in 2026; the old portal (<org>.enterprise.slack.com/help/requests) keeps only legacy requests, read-only, and its My Cases link signs you in to the new one. Keep a help.salesforce.com/s/cases tab open and signed in. Both commands run inside that tab and never print its session.

slack-support whoami                              # signed-in user and Slack org
slack-support list [--closed|--all] [--search=TEXT]
slack-support view 400000002                      # details, files, comments (--json)
slack-support comment 400000002 "Any update?" --confirm
slack-support create --subject="Link previews show &amp; on mobile" --severity=3 - --confirm < report.txt
intercom conversations                            # the Fin / support chats behind the cases
intercom read 215000000000002 [--limit=N]
intercom reply 215000000000002 "Thanks" --confirm [--wait]
  • comment, create, intercom reply and intercom new print what they would send and exit 3 without --confirm. Ask the user before confirming: they post as the user.
  • There is no case form. create asks the portal's AI agent (Fin) over Intercom for a case, declines live chat if offered, waits for the case number, then posts the description verbatim as a comment, because Fin writes its own summary as the case description and drops details (--no-comment skips that). If Fin reports no case number, it prints the chat and exits 1; continue with intercom.
  • <case> is the number shown in the portal or the 500… record id.
  • Flags take --name=value; a bare --flag never consumes the next word, so free text can follow it.
  • Not yet covered: close, reopen, escalate, severity changes and attachments. Wire formats, the auth details and what is verified live: references/support-portal.md.

Enterprise grid notes

Some Slack workspaces use Enterprise Grid (e.g. Adobe's E23RE8G4F). Some standard Web API methods like conversations.list and users.conversations return enterprise_is_restricted on these workspaces. The skill uses search.modules (module=channels) for channel discovery and conversations.open for DM channel lookup instead.

Admin user management (slack-ext)

slack-ext exposes Slack's legacy users.admin.* namespace for converting users between account types and managing guest channel access. It is a separate command from slack because it uses admin-only API methods that require a different usage pattern and carry stronger safety requirements.

Important caveats before using:

  • Audit attribution: these calls are indistinguishable from the human's own direct actions in Slack's channel event history. Read "CRITICAL: audit attribution" below first.
  • Token restriction: bot tokens (xoxb) are rejected with not_allowed_token_type. Only the xoxc browser session token works.
  • Undocumented legacy endpoints: these methods live in the users.admin.* namespace, which is separate from the documented admin.users.* namespace. They are not in Slack's public API docs and could change without notice.
  • Dry-run by default: every mutating command prints what would happen and exits without making any API call unless --confirm is supplied.

Quick start

# Check a user's current type and guest channels
slack-ext --ws=T06DUTYDQ status W5BPKRLUA

# Convert a member to a single-channel guest (dry run first)
slack-ext --ws=T06DUTYDQ set-single W5BPKRLUA --channel=C0899S7HV0E
slack-ext --ws=T06DUTYDQ set-single W5BPKRLUA --channel=C0899S7HV0E --confirm

# Convert a member to a multi-channel guest
slack-ext --ws=T06DUTYDQ set-multi W5BPKRLUA --confirm

# Promote a guest back to regular member (inverse of set-single / set-multi)
slack-ext --ws=T06DUTYDQ set-member W5BPKRLUA --confirm

# Add or remove a channel on a multi-channel guest
slack-ext --ws=T06DUTYDQ add-channel W5BPKRLUA --channel=C0899S7HV0E --confirm
slack-ext --ws=T06DUTYDQ remove-channel W5BPKRLUA --channel=C0899S7HV0E --confirm

Available commands

slack-ext status <user_id>

Show the user's current account type and, for guests, the channels they have access to. Read-only; no --confirm needed.

Output includes: real name, username, display name, account type (regular / multi-channel guest / single-channel guest / bot / deactivated), and a channel list for guests.

slack-ext --ws=T06DUTYDQ status W5BPKRLUA
slack-ext --ws=T06DUTYDQ status W5BPKRLUA --json   # include raw users.info object

slack-ext set-single <user_id> --channel=<ID> [--confirm]

Convert a member to a single-channel guest (Slack API: users.admin.setUltraRestricted). The user loses access to all channels except the specified one. Requires --ws and --channel. Without --confirm, shows what would happen and exits without changing anything.

The API parameter is channel (singular) — passing channels returns invalid_arguments. This is a known gotcha; the code and tests enforce it.

slack-ext set-multi <user_id> [--confirm]

Convert a member to a multi-channel guest (API: users.admin.setRestricted). After converting, use add-channel to grant channel access. Requires --ws.

slack-ext set-member <user_id> [--confirm]

Promote a guest back to a regular member (API: users.admin.setRegular). This is the inverse of set-single and set-multi. Requires --ws.

slack-ext add-channel <user_id> --channel=<ID> [--confirm]

Invite a multi-channel guest to an additional channel (conversations.invite). Requires --ws and --channel. Already-in-channel returns a no-op message.

slack-ext remove-channel <user_id> --channel=<ID> [--confirm]

Remove a guest from a channel (conversations.kick). Requires --ws and --channel. Not-in-channel returns a no-op message.

Safety policy

Every mutating command enforces four checks before touching Slack:

  1. Explicit confirmation — --confirm is required. Without it the command prints a full dry-run summary and exits 0.
  2. User resolution — the target user's real name, handle, and current account type are displayed before any change.
  3. Bot refusal — bot users are always rejected. Bot account types are owned by their app; forcing them to guest status would be destructive.
  4. Already-in-state — if the user is already in the requested state the command says so and exits without calling Slack.

Workspace ID (--ws)

All commands accept --ws=<TEAM_ID> (or --workspace=<TEAM_ID>). For mutating commands it is required, because team_id is a required API parameter and silently defaulting to the wrong workspace could affect the wrong person. For status it falls back to auto-detection from the Slack tab URL.

Run slack workspaces to list available workspace IDs.

Verifying without side effects

To confirm that auth, permissions, and parameter shape are all correct without changing a real user, use a deliberately invalid user id such as U000000BOGUS0. A correctly formed call returns user_not_found, which proves the token and method are working. This was used to verify all three users.admin.* methods before filing the PR that added this feature.

App manifest management (slack-ext app)

slack-ext app reads and changes Slack app configuration (App Manifest API) with an app configuration token if one is set, else the Slack tab's browser session (acts as you; --session/--no-session override); every write needs --confirm. Updates have no merge semantics (omitted fields are deleted), so writes export-modify-update. A removal you asked for (--remove) needs only --confirm; an unrequested deletion, including every omission in an app apply file, is refused unless --allow-deletions is given. permissions_updated: true means reinstall; token-rotate invalidates the old refresh token. Reference: references/app-manifest.md.

References

  • references/endpoints.md — full Slack Web API endpoint documentation, including the users.admin.* admin methods and the apps.manifest.* App Manifest API (wire format, update semantics, and the methods deliberately left unwired).
  • references/app-manifest.md — slack-ext app: the export-modify-update rule, the --allow-deletions gate, reinstall on permissions_updated, config-token vs browser-session auth, and every app subcommand.
  • references/enterprise-grid.md — the Enterprise Grid admin commands (eg-*, channel-*, approvals, admin-app): authentication, per-command APIs and parameters, wire facts, and what remains unverified.
  • references/watch-architecture.md — internals of slack watch and of slack post's reply auto-watch (observer, filter, TTL teardown, state files).
  • references/jsh-host.md — running on a host under jsh: install, slack watch with a callback command, post --watch-command, and what differs from SLICC 6.
  • references/support-portal.md — slack-support and intercom: the Salesforce Help Aura methods, the Intercom messenger calls, the Fin create flow, and what is verified live.

Enterprise Grid admin commands (slack-ext eg-*, channel-*, approvals, connect-*, admin-app)

Org-level admin commands (enterprise.users.admin.*, admin.conversations.*, conversations.sharedApprovals.list, admin.apps.*), for the org E06V3987PMY rather than one workspace. Full reference, with APIs, parameters, exit codes, wire facts and what remains unverified: references/enterprise-grid.md.

Audit attribution: xoxc calls are indistinguishable from the human's own actions in Slack's channel event history, and no working API tells them apart. Running any write here is the human doing it, as far as any Slack record shows. Evidence: references/enterprise-grid.md, "Audit attribution evidence".

Safety gates: every write is a dry run unless --confirm is given, and reads the state back after it. eg-forget is irreversible (never in an unattended loop). eg-set-ultra-restricted is unverified: don't use it in production.

  • Users: eg-status (read-only), eg-set-restricted, eg-set-regular, eg-deactivate (reversible; the wire's status=delete does not delete), eg-forget, eg-bulk-guest, eg-set-ultra-restricted.
  • Channels: channel-search (read-only), channel-to-public, channel-to-private, channel-archive (guards: --max-members, --min-idle-days; Slack Connect channels need --allow-shared), channel-unarchive.
  • Slack Connect: approvals [--detail] and approvals show <invite_id> (read-only), connect-revoke, guest-invite, connect-status (read-only; run before and after the next two), connect-invite (defaults to Post and Invite; --post-only), connect-permissions --upgrade|--downgrade. An unchanged read-back after connect-invite --confirm is expected until an invitee accepts.
  • Apps: admin-app approve|restrict|clear|permissions|list; a request_id is single-use.
Workspace
ai-ecoverse
Visibility
Public
Created
Last updated
Source
GitHub Actions
Repository
https://github.com/ai-ecoverse/skillsVerified
Badge
ai-ecoverse/advanced-skills badge