481 lines
17 KiB
Python
481 lines
17 KiB
Python
"""Read Slack Messages From Local IndexedDB
|
|
|
|
Parses the Chromium IndexedDB backing Slack's desktop app (Mac App Store
|
|
version). Finds the Redux state blob, decodes it with dfindexeddb's Blink
|
|
V8 deserializer, and prints cached messages.
|
|
|
|
Usage:
|
|
./slack-cli.py # Recent messages (all channels)
|
|
./slack-cli.py -c general # Filter by channel name (glob pattern)
|
|
./slack-cli.py -c 'team-*' -c general # Multiple channel filters
|
|
./slack-cli.py -x 'alerts-*' -x 'bot-*' # Exclude channels
|
|
./slack-cli.py -n 50 # Show last 50 messages
|
|
./slack-cli.py -u # Show unread messages only
|
|
./slack-cli.py -u -c general # Unread messages in a specific channel
|
|
./slack-cli.py -s 2h # Messages from the last 2 hours
|
|
./slack-cli.py -s 2026-04-15 # Messages since a specific date
|
|
./slack-cli.py --channels # List channels with message counts
|
|
./slack-cli.py --dump # Dump full Redux state to file
|
|
"""
|
|
|
|
import argparse
|
|
import fnmatch
|
|
import json
|
|
import os
|
|
import re
|
|
import sys
|
|
from collections import defaultdict
|
|
from datetime import datetime, timedelta
|
|
from pathlib import Path
|
|
|
|
from dfindexeddb.indexeddb.chromium.blink import V8ScriptValueDecoder
|
|
|
|
# ─── Constants ───────────────────────────────────────────────────────────────
|
|
|
|
SLACK_IDB_BASE = Path.home() / (
|
|
"Library/Containers/com.tinyspeck.slackmacgap"
|
|
"/Data/Library/Application Support/Slack/IndexedDB"
|
|
)
|
|
BLOB_DIR = SLACK_IDB_BASE / "https_app.slack.com_0.indexeddb.blob"
|
|
|
|
|
|
# ─── Helpers ─────────────────────────────────────────────────────────────────
|
|
|
|
|
|
def find_latest_blob() -> Path | None:
|
|
"""Find the Latest Blob File in the IndexedDB Blob Directory
|
|
|
|
Slack stores a single large blob containing the entire Redux state.
|
|
The blob number increments on every persist, so the latest file is
|
|
what we want.
|
|
"""
|
|
blob_files = [b for b in BLOB_DIR.rglob("*") if b.is_file()]
|
|
if not blob_files:
|
|
return None
|
|
blob_files.sort(key=lambda p: p.stat().st_mtime, reverse=True)
|
|
return blob_files[0]
|
|
|
|
|
|
def decode_blob(blob_path: Path) -> dict:
|
|
"""Decode a Blink IDB Value Wrapper Blob"""
|
|
raw = blob_path.read_bytes()
|
|
return V8ScriptValueDecoder.FromBytes(raw)
|
|
|
|
|
|
def ts_to_datetime(ts: str) -> datetime:
|
|
"""Convert Slack Timestamp to Datetime"""
|
|
try:
|
|
return datetime.fromtimestamp(float(ts))
|
|
except (ValueError, TypeError, OSError):
|
|
return datetime.min
|
|
|
|
|
|
def resolve_user(state: dict, user_id: str) -> str:
|
|
"""Resolve a Slack User ID to Display Name"""
|
|
if not isinstance(user_id, str):
|
|
return str(user_id)
|
|
members = state.get("members", {})
|
|
if not isinstance(members, dict):
|
|
return user_id
|
|
member = members.get(user_id)
|
|
if not isinstance(member, dict):
|
|
return user_id
|
|
|
|
# Slack Redux State Stores Name Fields at Top Level
|
|
name = member.get("display_name") or member.get("real_name") or member.get("name")
|
|
if name:
|
|
return name
|
|
|
|
# Also Check Nested Profile
|
|
profile = member.get("profile", {})
|
|
if isinstance(profile, dict):
|
|
name = profile.get("display_name") or profile.get("real_name")
|
|
if name:
|
|
return name
|
|
|
|
return user_id
|
|
|
|
|
|
def parse_since(value: str) -> datetime:
|
|
"""Parse a --since Value Into a Datetime
|
|
|
|
Supports relative durations (e.g. 30m, 2h, 3d) and absolute
|
|
dates/datetimes (e.g. 2026-04-15, '2026-04-15 10:00').
|
|
"""
|
|
# Relative Duration: <number><unit>
|
|
m = re.fullmatch(r"(\d+)([mhd])", value.strip())
|
|
if m:
|
|
amount = int(m.group(1))
|
|
unit = m.group(2)
|
|
delta = {"m": timedelta(minutes=amount), "h": timedelta(
|
|
hours=amount), "d": timedelta(days=amount)}[unit]
|
|
return datetime.now() - delta
|
|
|
|
# Absolute Datetime
|
|
for fmt in ("%Y-%m-%d %H:%M:%S", "%Y-%m-%d %H:%M", "%Y-%m-%d"):
|
|
try:
|
|
return datetime.strptime(value.strip(), fmt)
|
|
except ValueError:
|
|
continue
|
|
|
|
raise argparse.ArgumentTypeError(
|
|
f"invalid --since value: {value!r} "
|
|
f"(expected e.g. 30m, 2h, 3d, 2026-04-15, '2026-04-15 10:00')"
|
|
)
|
|
|
|
|
|
def build_channel_names(state: dict) -> dict[str, str]:
|
|
"""Build Channel ID -> Name Lookup"""
|
|
channels_store = state.get("channels", {})
|
|
names = {}
|
|
if isinstance(channels_store, dict):
|
|
for cid, cdata in channels_store.items():
|
|
if isinstance(cdata, dict):
|
|
names[cid] = cdata.get("name", cdata.get("name_normalized", cid))
|
|
return names
|
|
|
|
|
|
def get_workspace_domain(state: dict) -> str | None:
|
|
"""Get the Primary Workspace Domain From Teams Store"""
|
|
teams = state.get("teams", {})
|
|
if not isinstance(teams, dict):
|
|
return None
|
|
for _tid, team in teams.items():
|
|
if isinstance(team, dict) and team.get("url"):
|
|
return team.get("domain")
|
|
# Fallback to First Team With a Domain
|
|
for _tid, team in teams.items():
|
|
if isinstance(team, dict) and team.get("domain"):
|
|
return team.get("domain")
|
|
return None
|
|
|
|
|
|
def slack_url(domain: str, channel_id: str, ts: str, thread_ts: str | None = None) -> str:
|
|
"""Build a Slack Deep Link URL
|
|
|
|
Message timestamps become URL path segments by removing the dot:
|
|
1776219948.820859 -> p1776219948820859
|
|
Thread replies additionally include ?thread_ts=...&cid=...
|
|
"""
|
|
ts_url = "p" + ts.replace(".", "")
|
|
url = f"https://{domain}.slack.com/archives/{channel_id}/{ts_url}"
|
|
if thread_ts and thread_ts != ts:
|
|
url += f"?thread_ts={thread_ts}&cid={channel_id}"
|
|
return url
|
|
|
|
|
|
# ─── Commands ────────────────────────────────────────────────────────────────
|
|
|
|
|
|
def build_read_cursors(state: dict) -> dict[str, float]:
|
|
"""Build Channel ID -> Read Cursor Timestamp Lookup
|
|
|
|
The channelCursors store maps channel IDs to the timestamp of the
|
|
last-read message. Messages with ts > cursor are unread.
|
|
"""
|
|
cursors = state.get("channelCursors", {})
|
|
result = {}
|
|
if isinstance(cursors, dict):
|
|
for cid, ts in cursors.items():
|
|
try:
|
|
result[cid] = float(ts)
|
|
except (ValueError, TypeError):
|
|
continue
|
|
return result
|
|
|
|
|
|
def channel_matches(name: str, patterns: list[str]) -> bool:
|
|
"""Check if a Channel Name Matches Any of the Glob Patterns"""
|
|
name_lower = name.lower()
|
|
return any(fnmatch.fnmatch(name_lower, p.lower()) for p in patterns)
|
|
|
|
|
|
def cmd_messages(
|
|
state: dict,
|
|
include_channels: list[str] | None,
|
|
exclude_channels: list[str] | None,
|
|
count: int,
|
|
unread_only: bool = False,
|
|
since: datetime | None = None,
|
|
):
|
|
"""Print Messages From Slack State"""
|
|
messages_store = state.get("messages", {})
|
|
channel_names = build_channel_names(state)
|
|
read_cursors = build_read_cursors(state) if unread_only else {}
|
|
domain = get_workspace_domain(state)
|
|
|
|
# Collect All Messages
|
|
all_msgs = []
|
|
for cid, channel_msgs in messages_store.items():
|
|
if not isinstance(channel_msgs, dict):
|
|
continue
|
|
ch_name = channel_names.get(cid, cid)
|
|
|
|
# Apply Channel Include / Exclude Filters
|
|
if include_channels and not channel_matches(ch_name, include_channels):
|
|
continue
|
|
if exclude_channels and channel_matches(ch_name, exclude_channels):
|
|
continue
|
|
|
|
# Determine Read Cursor for Unread Filtering
|
|
cursor = read_cursors.get(cid, 0.0) if unread_only else 0.0
|
|
|
|
# Convert --since Datetime to Unix Timestamp for Comparison
|
|
since_ts = since.timestamp() if since else 0.0
|
|
|
|
for ts, msg in channel_msgs.items():
|
|
if not isinstance(msg, dict):
|
|
continue
|
|
|
|
# Skip Messages Before Cutoff (Unread Cursor or --since)
|
|
try:
|
|
ts_f = float(ts)
|
|
except (ValueError, TypeError):
|
|
continue
|
|
if unread_only and ts_f <= cursor:
|
|
continue
|
|
if since and ts_f < since_ts:
|
|
continue
|
|
|
|
text = msg.get("text", "")
|
|
if not text or not isinstance(text, str):
|
|
continue
|
|
|
|
user_id = msg.get("user", msg.get("bot_id", "?"))
|
|
user_name = resolve_user(state, user_id)
|
|
subtype = msg.get("subtype", "")
|
|
|
|
# dfindexeddb Represents JS undefined as an Undefined object
|
|
if not isinstance(subtype, str):
|
|
subtype = ""
|
|
|
|
# Resolve Thread Timestamp
|
|
thread_ts = msg.get("thread_ts", "")
|
|
if not isinstance(thread_ts, str):
|
|
thread_ts = ""
|
|
|
|
all_msgs.append({
|
|
"channel": ch_name,
|
|
"channel_id": cid,
|
|
"ts": ts,
|
|
"thread_ts": thread_ts or None,
|
|
"dt": ts_to_datetime(ts),
|
|
"user": user_name,
|
|
"user_id": user_id,
|
|
"text": text,
|
|
"subtype": subtype,
|
|
})
|
|
|
|
# Sort by Timestamp (Most Recent Last)
|
|
all_msgs.sort(key=lambda m: m["dt"])
|
|
|
|
# Group Thread Replies Under Their Parents
|
|
threads: dict[str, list[dict]] = defaultdict(list)
|
|
top_level: list[dict] = []
|
|
for msg in all_msgs:
|
|
thread_ts = msg["thread_ts"]
|
|
if thread_ts and thread_ts != msg["ts"]:
|
|
threads[thread_ts].append(msg)
|
|
else:
|
|
top_level.append(msg)
|
|
|
|
# Build Display List — Each Top-Level Entry Followed by Its Replies
|
|
# item = (msg | None, depth) — None msg means orphan thread header
|
|
# depth 0 = root (top-level message or orphan thread header)
|
|
# depth 1 = thread reply
|
|
display: list[tuple[dict | None, int]] = []
|
|
seen_parents: set[str] = {m["ts"] for m in top_level}
|
|
|
|
for msg in top_level:
|
|
display.append((msg, 0))
|
|
for reply in threads.get(msg["ts"], []):
|
|
display.append((reply, 1))
|
|
|
|
# Collect Orphan Thread Groups — Replies Whose Parent Isn't Shown
|
|
orphan_groups: list[tuple[str, list[dict]]] = []
|
|
for thread_ts, replies in threads.items():
|
|
if thread_ts not in seen_parents:
|
|
orphan_groups.append((thread_ts, replies))
|
|
|
|
# Sort Orphan Groups by Earliest Reply Timestamp
|
|
orphan_groups.sort(key=lambda g: g[1][0]["dt"])
|
|
|
|
# Append Each Orphan Group With a Header Placeholder
|
|
for thread_ts, replies in orphan_groups:
|
|
# Use First Reply's Channel and ID for the Header
|
|
header = {
|
|
"channel": replies[0]["channel"],
|
|
"channel_id": replies[0]["channel_id"],
|
|
"thread_ts": thread_ts,
|
|
}
|
|
display.append((None, 0)) # Placeholder for header
|
|
for reply in replies:
|
|
display.append((reply, 1))
|
|
# Patch the Placeholder With Header Info
|
|
display[-len(replies) - 1] = (header, 0)
|
|
|
|
# Print Last N Messages (Count depth=0 Entries Only)
|
|
if len(display) > 0:
|
|
# Walk Backwards to Find the Cutoff That Includes `count` Roots
|
|
roots_seen = 0
|
|
start_idx = len(display)
|
|
for i in range(len(display) - 1, -1, -1):
|
|
if display[i][1] == 0:
|
|
roots_seen += 1
|
|
if roots_seen > count:
|
|
break
|
|
start_idx = i
|
|
|
|
visible = display[start_idx:]
|
|
else:
|
|
visible = []
|
|
|
|
ts_color = "\033[90m"
|
|
ch_color = "\033[36m"
|
|
user_color = "\033[33m"
|
|
reset = "\033[0m"
|
|
|
|
bar_str = f"\033[90m│\033[0m"
|
|
|
|
for idx, (msg, depth) in enumerate(visible):
|
|
# Peek Ahead to See if Next Item Is Still a Thread Reply
|
|
next_is_reply = (idx + 1 < len(visible) and visible[idx + 1][1] > 0)
|
|
|
|
# Orphan Thread Header
|
|
if msg is not None and "dt" not in msg:
|
|
header_line = f"\033[90m↳ thread in {ch_color}#{msg['channel']}{reset}"
|
|
if domain and msg.get("channel_id") and msg.get("thread_ts"):
|
|
link = slack_url(domain, msg["channel_id"], msg["thread_ts"])
|
|
header_line += f" \033[90m{link}{reset}"
|
|
print(header_line)
|
|
continue
|
|
|
|
dt_str = msg["dt"].strftime("%Y-%m-%d %H:%M:%S")
|
|
subtype_tag = f" [{msg['subtype']}]" if msg["subtype"] else ""
|
|
bar = f"{bar_str} " if depth > 0 else ""
|
|
|
|
# Build Slack Link for Top-Level Messages
|
|
link_suffix = ""
|
|
if domain and depth == 0:
|
|
link = slack_url(domain, msg["channel_id"], msg["ts"])
|
|
link_suffix = f" {ts_color}{link}{reset}"
|
|
|
|
print(
|
|
f"{bar}{ts_color}{dt_str}{reset} "
|
|
f"{ch_color}#{msg['channel']}{reset} "
|
|
f"{user_color}{msg['user']}{reset}{subtype_tag}{link_suffix}"
|
|
)
|
|
|
|
# Indent Message Text (Prefix Every Line for Multi-Line Messages)
|
|
text_prefix = f"{bar_str} " if depth > 0 else " "
|
|
for line in msg["text"][:500].split("\n"):
|
|
print(f"{text_prefix}{line}")
|
|
|
|
# Connecting Bar Between Thread Messages
|
|
if next_is_reply:
|
|
print(bar_str)
|
|
else:
|
|
print()
|
|
|
|
root_count = sum(1 for _, d in visible if d == 0)
|
|
total_roots = sum(1 for _, d in display if d == 0)
|
|
label = "unread messages" if unread_only else "messages"
|
|
if since:
|
|
label += f" since {since.strftime('%Y-%m-%d %H:%M')}"
|
|
print(f"--- Showing {root_count} of {total_roots} {label} ---")
|
|
|
|
|
|
def cmd_channels(state: dict):
|
|
"""List Channels With Message Counts"""
|
|
messages_store = state.get("messages", {})
|
|
channel_names = build_channel_names(state)
|
|
|
|
counts = {}
|
|
for cid, channel_msgs in messages_store.items():
|
|
if not isinstance(channel_msgs, dict):
|
|
continue
|
|
ch_name = channel_names.get(cid, cid)
|
|
msg_count = sum(
|
|
1 for v in channel_msgs.values()
|
|
if isinstance(v, dict) and v.get("text")
|
|
)
|
|
if msg_count > 0:
|
|
counts[ch_name] = msg_count
|
|
|
|
for name, c in sorted(counts.items(), key=lambda x: -x[1]):
|
|
print(f" {c:5d} #{name}")
|
|
|
|
print(f"\n--- {len(counts)} channels with cached messages ---")
|
|
|
|
|
|
def cmd_dump(state: dict, output: str):
|
|
"""Dump Full Redux State to File"""
|
|
with open(output, "w") as f:
|
|
json.dump(state, f, indent=2, default=str, ensure_ascii=False)
|
|
size_mb = os.path.getsize(output) / 1024 / 1024
|
|
print(f"Dumped {size_mb:.1f}MB to {output}")
|
|
|
|
|
|
# ─── Main ────────────────────────────────────────────────────────────────────
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(
|
|
description="Read Slack messages from local IndexedDB"
|
|
)
|
|
parser.add_argument(
|
|
"-c", "--channel", action="append", dest="channels",
|
|
help="Include channels matching glob pattern (repeatable, e.g. -c 'team-*' -c general)"
|
|
)
|
|
parser.add_argument(
|
|
"-x", "--exclude", action="append", dest="exclude_channels",
|
|
help="Exclude channels matching glob pattern (repeatable, e.g. -x 'alerts-*' -x 'bot-*')"
|
|
)
|
|
parser.add_argument(
|
|
"-n", "--count", type=int, default=30,
|
|
help="Number of messages to show (default: 30)"
|
|
)
|
|
parser.add_argument(
|
|
"-u", "--unread", action="store_true",
|
|
help="Show only unread messages (based on read cursor position)"
|
|
)
|
|
parser.add_argument(
|
|
"-s", "--since", type=parse_since,
|
|
help="Show messages since time (e.g. 30m, 2h, 3d, 2026-04-15, '2026-04-15 10:00')"
|
|
)
|
|
parser.add_argument(
|
|
"--channels", action="store_true", dest="list_channels",
|
|
help="List channels with message counts"
|
|
)
|
|
parser.add_argument(
|
|
"--dump", nargs="?", const="slack_state.json",
|
|
help="Dump full state to JSON file"
|
|
)
|
|
args = parser.parse_args()
|
|
|
|
# Find and Decode the Blob
|
|
blob_path = find_latest_blob()
|
|
if not blob_path:
|
|
print(
|
|
"No blob files found. Is Slack installed and has it been opened?",
|
|
file=sys.stderr,
|
|
)
|
|
sys.exit(1)
|
|
|
|
size_mb = blob_path.stat().st_size / 1024 / 1024
|
|
print(f"Reading blob: {blob_path} ({size_mb:.1f}MB)", file=sys.stderr)
|
|
state = decode_blob(blob_path)
|
|
|
|
# Dispatch Command
|
|
if args.dump:
|
|
cmd_dump(state, args.dump)
|
|
elif args.list_channels:
|
|
cmd_channels(state)
|
|
else:
|
|
cmd_messages(state, args.channels, args.exclude_channels,
|
|
args.count, args.unread, args.since)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|