slackctl 0.1.0__py3-none-any.whl

slackctl/__init__.py

@@ -0,0 +1,5 @@
+"""
+slack-wipe: A CLI tool to purge your Slack message history.
+"""
+
+__version__ = "0.1.0"

slackctl/cli.py

@@ -0,0 +1,218 @@
+import os
+from pathlib import Path
+import logging
+import sys
+import click
+
+from slackctl.purger import SlackPurger
+from slackctl.exporter import SlackExporter
+
+def load_dotenv(dotenv_path: str = ".env") -> None:
+    """Load environment variables from a .env file if it exists."""
+    path = Path(dotenv_path)
+    if not path.is_file():
+        return
+    try:
+        with open(path, "r", encoding="utf-8") as f:
+            for line in f:
+                line = line.strip()
+                if not line or line.startswith("#"):
+                    continue
+                if "=" in line:
+                    key, val = line.split("=", 1)
+                    key = key.strip()
+                    val = val.strip()
+                    if val.startswith('"'):
+                        end_idx = val.find('"', 1)
+                        if end_idx != -1:
+                            val = val[1:end_idx]
+                    elif val.startswith("'"):
+                        end_idx = val.find("'", 1)
+                        if end_idx != -1:
+                            val = val[1:end_idx]
+                    else:
+                        if " #" in val:
+                            val = val.split(" #", 1)[0].strip()
+                        elif val.startswith("#"):
+                            val = ""
+                    if key and key not in os.environ:
+                        os.environ[key] = val
+    except Exception:
+        pass
+
+load_dotenv()
+
+def setup_logging(log_file: str, verbose: bool) -> logging.Logger:
+    """Set up the application logger with console and file destinations."""
+    logger = logging.getLogger("slackctl")
+    logger.setLevel(logging.DEBUG)
+    logger.propagate = False
+
+    logger.handlers.clear()
+
+    console_level = logging.DEBUG if verbose else logging.INFO
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(console_level)
+    console_formatter = logging.Formatter("[%(levelname)s] %(message)s")
+    console_handler.setFormatter(console_formatter)
+    logger.addHandler(console_handler)
+
+    if log_file:
+        try:
+            file_handler = logging.FileHandler(log_file, encoding="utf-8")
+            file_handler.setLevel(logging.DEBUG)
+            file_formatter = logging.Formatter(
+                "%(asctime)s [%(levelname)s] [%(name)s:%(lineno)d] %(message)s"
+            )
+            file_handler.setFormatter(file_formatter)
+            logger.addHandler(file_handler)
+        except Exception as e:
+            click.echo(f"Warning: Could not configure log file {log_file}: {e}", err=True)
+
+    return logger
+
+@click.group()
+def main():
+    """slackctl: A collection of handy CLI utilities for Slack."""
+    pass
+
+@main.command("purge")
+@click.option(
+    "--token", "-t",
+    envvar="SLACK_TOKEN",
+    help="Slack User OAuth Token (starts with xoxp-). Can also be set via SLACK_TOKEN environment variable.",
+)
+@click.option(
+    "--channel", "-c",
+    envvar="SLACK_CHANNEL",
+    help="Target Slack Channel ID. Can also be set via SLACK_CHANNEL environment variable.",
+)
+@click.option(
+    "--dry-run/--no-dry-run",
+    default=True,
+    show_default=True,
+    help="Dry run mode (list messages that would be deleted, without actually deleting them).",
+)
+@click.option(
+    "--yes", "-y",
+    is_flag=True,
+    help="Skip safety confirmation prompt when running in live mode (--no-dry-run).",
+)
+@click.option(
+    "--limit", "-l",
+    default=200,
+    show_default=True,
+    help="Max messages to request per fetch request.",
+)
+@click.option(
+    "--sleep", "-s",
+    default=1.2,
+    show_default=True,
+    help="Delay in seconds between deletion requests (Slack rate limit is approx 1 req/sec).",
+)
+@click.option(
+    "--log-file",
+    default="slack_wipe.log",
+    show_default=True,
+    help="Path to file where detailed logs will be written.",
+)
+@click.option(
+    "--verbose", "-v",
+    is_flag=True,
+    help="Show verbose output in the terminal (including reasons for skipped messages).",
+)
+def purge(token, channel, dry_run, yes, limit, sleep, log_file, verbose):
+    """Safely bulk-delete your messages from a Slack channel."""
+    logger = setup_logging(log_file, verbose)
+
+    if not token:
+        logger.error("Slack Token is required. Use --token/-t or set SLACK_TOKEN environment variable.")
+        sys.exit(1)
+
+    if not channel:
+        logger.error("Slack Channel ID is required. Use --channel/-c or set SLACK_CHANNEL environment variable.")
+        sys.exit(1)
+
+    if not dry_run and not yes:
+        msg = f"WARNING: You are about to permanently delete your messages in channel {channel}. This cannot be undone! Continue?"
+        if not click.confirm(msg, default=False):
+            logger.info("Purge cancelled by user.")
+            sys.exit(0)
+
+    purger = SlackPurger(
+        token=token,
+        channel_id=channel,
+        dry_run=dry_run,
+        rate_limit_sleep=sleep,
+        logger=logger
+    )
+
+    try:
+        purger.purge(limit=limit)
+    except Exception as e:
+        logger.critical(f"Execution failed: {e}")
+        sys.exit(2)
+
+@main.command("export")
+@click.option(
+    "--token", "-t",
+    envvar="SLACK_TOKEN",
+    help="Slack User OAuth Token (starts with xoxp-). Can also be set via SLACK_TOKEN environment variable.",
+)
+@click.option(
+    "--channel", "-c",
+    envvar="SLACK_CHANNEL",
+    help="Optional target Slack Channel ID. If omitted, exports every message you ever sent across all channels.",
+)
+@click.option(
+    "--output", "-o",
+    default="slack_export.html",
+    show_default=True,
+    help="Path to output file where the export will be saved.",
+)
+@click.option(
+    "--format", "-f",
+    type=click.Choice(["html", "json", "markdown"], case_sensitive=False),
+    default="html",
+    show_default=True,
+    help="Export output format: 'html' (interactive dashboard), 'json' (raw data), 'markdown' (readable log).",
+)
+@click.option(
+    "--log-file",
+    default="slack_export.log",
+    show_default=True,
+    help="Path to file where detailed logs will be written.",
+)
+@click.option(
+    "--verbose", "-v",
+    is_flag=True,
+    help="Show verbose output in the terminal.",
+)
+def export(token, channel, output, format, log_file, verbose):
+    """Export all your messages in a specific channel or across all Slack channels."""
+    logger = setup_logging(log_file, verbose)
+
+    if not token:
+        logger.error("Slack Token is required. Use --token/-t or set SLACK_TOKEN environment variable.")
+        sys.exit(1)
+
+    exporter = SlackExporter(
+        token=token,
+        channel_id=channel,
+        logger=logger
+    )
+
+    try:
+        exporter.export(output_path=output, format_type=format)
+    except Exception as e:
+        logger.critical(f"Export failed: {e}")
+        sys.exit(2)
+
+def wipe_compat():
+    """Compatibility alias to run 'purge' directly when 'slack-wipe' is called."""
+    # Inject 'purge' into argv so Click routes to the purge command
+    sys.argv.insert(1, "purge")
+    main()
+
+if __name__ == "__main__":
+    main()

slackctl/exporter.py

@@ -0,0 +1,251 @@
+import json
+import logging
+import time
+import datetime
+from pathlib import Path
+import requests
+
+class SlackExporter:
+    """Handles fetching and exporting user messages across all or specific Slack channels."""
+
+    def __init__(
+        self,
+        token: str,
+        channel_id: str | None = None,
+        logger: logging.Logger | None = None
+    ):
+        self.token = token
+        self.channel_id = channel_id
+        self.headers = {"Authorization": f"Bearer {token}"}
+        self.logger = logger or logging.getLogger(__name__)
+        self.user_id = None
+        self.username = None
+
+    def _request_with_retry(self, method: str, url: str, **kwargs) -> dict:
+        """Helper to send HTTP requests with support for automatic 429 rate limit retries."""
+        max_retries = 5
+        for attempt in range(max_retries):
+            try:
+                resp = requests.request(method, url, **kwargs)
+                
+                if resp.status_code == 429:
+                    retry_after = int(resp.headers.get("Retry-After", 10))
+                    self.logger.warning(f"Rate limited (HTTP 429). Retrying after {retry_after} seconds...")
+                    time.sleep(retry_after)
+                    continue
+
+                resp.raise_for_status()
+                data = resp.json()
+
+                if not data.get("ok") and data.get("error") == "ratelimited":
+                    retry_after = int(resp.headers.get("Retry-After", 10))
+                    self.logger.warning(f"Rate limited (JSON error). Retrying after {retry_after} seconds...")
+                    time.sleep(retry_after)
+                    continue
+
+                return data
+            except requests.exceptions.RequestException as e:
+                if attempt == max_retries - 1:
+                    self.logger.error(f"Network error after {max_retries} attempts: {e}")
+                    raise
+                self.logger.warning(f"Network error: {e}. Retrying in 5 seconds...")
+                time.sleep(5)
+
+    def authenticate(self) -> str:
+        """Verify credentials and retrieve User ID."""
+        self.logger.info("Connecting to Slack API and authenticating...")
+        try:
+            data = self._request_with_retry("GET", "https://slack.com/api/auth.test", headers=self.headers)
+            if not data.get("ok"):
+                raise RuntimeError(f"Authentication failed: {data.get('error')}")
+            
+            self.user_id = data["user_id"]
+            self.username = data["user"]
+            self.logger.info(f"Authenticated successfully as: {self.username} ({self.user_id})")
+            return self.user_id
+        except Exception as e:
+            self.logger.error(f"Error during authentication: {e}")
+            raise
+
+    def fetch_all_messages(self, limit: int = 100) -> list:
+        """Fetch all messages sent by this user using the search API."""
+        if not self.user_id:
+            self.authenticate()
+
+        query = f"from:<@{self.user_id}>"
+        if self.channel_id:
+            query += f" in:<#{self.channel_id}>"
+            self.logger.info(f"Searching for messages in channel {self.channel_id}...")
+        else:
+            self.logger.info("Searching for your messages across all accessible channels...")
+
+        all_messages = []
+        page = 1
+
+        while True:
+            self.logger.debug(f"Querying search page {page}...")
+            try:
+                data = self._request_with_retry(
+                    "GET",
+                    "https://slack.com/api/search.messages",
+                    headers=self.headers,
+                    params={
+                        "query": query,
+                        "count": min(limit, 100),
+                        "page": page,
+                        "sort": "timestamp",
+                        "sort_dir": "asc"
+                    }
+                )
+            except Exception as e:
+                self.logger.error(f"Failed to query search API: {e}")
+                break
+
+            if not data.get("ok"):
+                self.logger.error(f"Slack API search error: {data.get('error')}")
+                break
+
+            messages_data = data.get("messages", {})
+            matches = messages_data.get("matches", [])
+            
+            if not matches:
+                break
+
+            for msg in matches:
+                channel_info = msg.get("channel", {})
+                ch_id = channel_info.get("id") if isinstance(channel_info, dict) else channel_info
+                ch_name = channel_info.get("name") if isinstance(channel_info, dict) else ""
+
+                all_messages.append({
+                    "ts": msg.get("ts"),
+                    "text": msg.get("text", ""),
+                    "channel_id": ch_id,
+                    "channel_name": ch_name,
+                    "permalink": msg.get("permalink", ""),
+                    "username": msg.get("username", self.username),
+                    "user_id": msg.get("user", self.user_id)
+                })
+
+            self.logger.info(f"Fetched {len(all_messages)} messages so far...")
+
+            paging = messages_data.get("paging", {})
+            total_pages = paging.get("pages", 1)
+            if page >= total_pages:
+                break
+            page += 1
+            time.sleep(0.5)
+
+        self.logger.info(f"Retrieved {len(all_messages)} messages total.")
+        return all_messages
+
+    def export(self, output_path: str, format_type: str) -> None:
+        """Run fetch and format/save to output file."""
+        messages = self.fetch_all_messages()
+
+        if format_type.lower() == "json":
+            self._export_json(messages, output_path)
+        elif format_type.lower() == "markdown":
+            self._export_markdown(messages, output_path)
+        else:
+            self._export_html(messages, output_path)
+
+    def _export_json(self, messages: list, path: str) -> None:
+        with open(path, "w", encoding="utf-8") as f:
+            json.dump({
+                "meta": {
+                    "username": self.username,
+                    "user_id": self.user_id,
+                    "exported_at": datetime.datetime.now().isoformat(),
+                    "total_messages": len(messages)
+                },
+                "messages": messages
+            }, f, indent=2, ensure_ascii=False)
+        self.logger.info(f"JSON export saved to: {path}")
+
+    def _export_markdown(self, messages: list, path: str) -> None:
+        messages_sorted = sorted(messages, key=lambda x: float(x.get("ts") or 0))
+        lines = [
+            f"# Slack Message Export for @{self.username}",
+            f"- **User ID**: `{self.user_id}`",
+            f"- **Export Date**: {datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')}",
+            f"- **Total Messages**: {len(messages)}",
+            "",
+            "---",
+            ""
+        ]
+
+        grouped = {}
+        for m in messages_sorted:
+            ch = m.get("channel_name") or m.get("channel_id") or "unknown-channel"
+            grouped.setdefault(ch, []).append(m)
+
+        for channel, msgs in sorted(grouped.items()):
+            lines.append(f"## Channel: #{channel}")
+            for m in msgs:
+                try:
+                    dt = datetime.datetime.fromtimestamp(float(m["ts"])).strftime("%Y-%m-%d %H:%M:%S")
+                except:
+                    dt = m.get("ts")
+                
+                text = m.get("text", "").replace("\n", " ")
+                link = f" ([Link]({m['permalink']}))" if m.get("permalink") else ""
+                lines.append(f"- **[{dt}]**: {text}{link}")
+            lines.append("")
+
+        with open(path, "w", encoding="utf-8") as f:
+            f.write("\n".join(lines))
+        self.logger.info(f"Markdown export saved to: {path}")
+
+    def _export_html(self, messages: list, path: str) -> None:
+        messages_sorted = sorted(messages, key=lambda x: float(x.get("ts") or 0))
+        
+        for m in messages_sorted:
+            try:
+                m["formatted_date"] = datetime.datetime.fromtimestamp(float(m["ts"])).strftime("%Y-%m-%d %H:%M:%S")
+            except:
+                m["formatted_date"] = m.get("ts", "")
+
+        channel_counts = {}
+        for m in messages_sorted:
+            ch_name = m.get("channel_name") or m.get("channel_id") or "unknown"
+            channel_counts[ch_name] = channel_counts.get(ch_name, 0) + 1
+
+        channels_list = [{"name": name, "count": count} for name, count in sorted(channel_counts.items())]
+
+        html_content = self._get_html_template(messages_sorted, channels_list)
+        
+        with open(path, "w", encoding="utf-8") as f:
+            f.write(html_content)
+        self.logger.info(f"Beautiful HTML report saved to: {path}")
+
+    def _get_html_template(self, messages: list, channels: list) -> str:
+        messages_json = json.dumps(messages)
+        channels_json = json.dumps(channels)
+        
+        templates_dir = Path(__file__).parent / "templates"
+        try:
+            with open(templates_dir / "index.html", "r", encoding="utf-8") as f:
+                index_html = f.read()
+            with open(templates_dir / "style.css", "r", encoding="utf-8") as f:
+                style_css = f.read()
+            with open(templates_dir / "app.js", "r", encoding="utf-8") as f:
+                app_js = f.read()
+        except Exception as e:
+            self.logger.error(f"Failed to load HTML templates from {templates_dir}: {e}")
+            raise
+
+        template = (
+            index_html
+            .replace("{{css_content}}", style_css)
+            .replace("{{js_content}}", app_js)
+        )
+
+        return (
+            template
+            .replace("{{username}}", self.username or "")
+            .replace("{{user_id}}", self.user_id or "")
+            .replace("{{messages_count}}", str(len(messages)))
+            .replace("{{channels_count}}", str(len(channels)))
+            .replace("{{messages_json}}", messages_json)
+            .replace("{{channels_json}}", channels_json)
+        )

slackctl/purger.py

@@ -0,0 +1,198 @@
+import time
+import logging
+import requests
+
+class SlackPurger:
+    """Handles authentication and deletion of user messages in a Slack channel."""
+
+    def __init__(
+        self,
+        token: str,
+        channel_id: str,
+        dry_run: bool = True,
+        rate_limit_sleep: float = 1.2,
+        logger: logging.Logger | None = None
+    ):
+        self.token = token
+        self.channel_id = channel_id
+        self.dry_run = dry_run
+        self.rate_limit_sleep = rate_limit_sleep
+        self.headers = {"Authorization": f"Bearer {token}"}
+        self.logger = logger or logging.getLogger(__name__)
+        self.user_id = None
+        self.username = None
+
+    def _request_with_retry(self, method: str, url: str, **kwargs) -> dict:
+        max_retries = 5
+        for attempt in range(max_retries):
+            try:
+                resp = requests.request(method, url, **kwargs)
+                
+                if resp.status_code == 429:
+                    retry_after = int(resp.headers.get("Retry-After", 10))
+                    self.logger.warning(f"Rate limited (HTTP 429). Retrying after {retry_after} seconds...")
+                    time.sleep(retry_after)
+                    continue
+
+                resp.raise_for_status()
+                data = resp.json()
+
+                if not data.get("ok") and data.get("error") == "ratelimited":
+                    retry_after = int(resp.headers.get("Retry-After", 10))
+                    self.logger.warning(f"Rate limited (JSON error). Retrying after {retry_after} seconds...")
+                    time.sleep(retry_after)
+                    continue
+
+                return data
+            except requests.exceptions.RequestException as e:
+                if attempt == max_retries - 1:
+                    self.logger.error(f"Network error after {max_retries} attempts: {e}")
+                    raise
+                self.logger.warning(f"Network error: {e}. Retrying in 5 seconds...")
+                time.sleep(5)
+
+    def authenticate(self) -> str:
+        self.logger.info("Connecting to Slack API and authenticating...")
+        try:
+            data = self._request_with_retry("GET", "https://slack.com/api/auth.test", headers=self.headers)
+            if not data.get("ok"):
+                raise RuntimeError(f"Authentication failed: {data.get('error')}")
+            
+            self.user_id = data["user_id"]
+            self.username = data["user"]
+            self.logger.info(f"Authenticated successfully as: {self.username} ({self.user_id})")
+            return self.user_id
+        except Exception as e:
+            self.logger.error(f"Error during authentication: {e}")
+            raise
+
+    def delete_message(self, ts: str) -> dict:
+        return self._request_with_retry(
+            "POST",
+            "https://slack.com/api/chat.delete",
+            headers=self.headers,
+            json={"channel": self.channel_id, "ts": ts},
+        )
+
+    def purge(self, limit: int = 100) -> dict:
+        if not self.user_id:
+            self.authenticate()
+
+        self.logger.info(f"Targeting channel: {self.channel_id}")
+        self.logger.info(f"Mode: {'DRY RUN (no messages will be deleted)' if self.dry_run else 'LIVE (messages will be permanently deleted)'}")
+
+        stats = {
+            "deleted": 0,
+            "skipped": 0,
+            "errors": 0
+        }
+        processed_ts = set()
+        page = 1
+
+        while True:
+            query = f"from:<@{self.user_id}> in:<#{self.channel_id}>"
+            self.logger.debug(f"Searching Slack messages with query: '{query}' (page: {page})")
+            
+            try:
+                data = self._request_with_retry(
+                    "GET",
+                    "https://slack.com/api/search.messages",
+                    headers=self.headers,
+                    params={
+                        "query": query,
+                        "count": min(limit, 100),
+                        "page": page,
+                        "sort": "timestamp",
+                        "sort_dir": "asc"
+                    }
+                )
+            except Exception as e:
+                self.logger.error(f"Failed to query search API: {e}")
+                break
+
+            if not data.get("ok"):
+                error_msg = data.get("error", "unknown error")
+                if error_msg == "missing_scope":
+                    self.logger.error(
+                        "Slack API error: missing_scope. "
+                        "The 'search.messages' API requires the 'search:read' User OAuth scope. "
+                        "Please go to your Slack App console, add 'search:read' user scope under OAuth & Permissions, "
+                        "reinstall the app to your workspace, and try again."
+                    )
+                else:
+                    self.logger.error(f"Slack API search error: {error_msg}")
+                break
+
+            messages_data = data.get("messages", {})
+            matches = messages_data.get("matches", [])
+            
+            if not matches:
+                self.logger.debug("No search matches found.")
+                break
+
+            self.logger.debug(f"Found {len(matches)} search matches on page {page}.")
+
+            new_items_processed = 0
+            successful_deletions = 0
+
+            for msg in matches:
+                ts = msg.get("ts")
+                if not ts:
+                    continue
+
+                if ts in processed_ts:
+                    continue
+
+                processed_ts.add(ts)
+                new_items_processed += 1
+                
+                msg_channel = msg.get("channel", {})
+                msg_channel_id = msg_channel.get("id") if isinstance(msg_channel, dict) else msg_channel
+                if msg_channel_id != self.channel_id:
+                    self.logger.debug(f"Skipping search result in different channel: {msg_channel_id}")
+                    stats["skipped"] += 1
+                    continue
+
+                preview = msg.get("text", "")[:60].replace("\n", " ")
+
+                if self.dry_run:
+                    self.logger.info(f"[DRY RUN] Would delete message [{ts}]: {preview!r}")
+                    stats["deleted"] += 1
+                else:
+                    self.logger.info(f"Deleting message [{ts}]: {preview!r}")
+                    try:
+                        result = self.delete_message(ts)
+                        if result.get("ok"):
+                            self.logger.info(f"Successfully deleted message [{ts}]")
+                            stats["deleted"] += 1
+                            successful_deletions += 1
+                        else:
+                            err = result.get("error", "unknown error")
+                            self.logger.error(f"Failed to delete message [{ts}]: {err}")
+                            stats["errors"] += 1
+                    except Exception as e:
+                        self.logger.error(f"Exception deleting message [{ts}]: {e}")
+                        stats["errors"] += 1
+
+                    time.sleep(self.rate_limit_sleep)
+
+            # Handle pagination when deleting:
+            # - Dry run: advance pages normally.
+            # - Live run: deleted items disappear from results, shifting future items to page 1.
+            # Only advance the page index if we didn't perform any successful deletions on this page.
+            if self.dry_run:
+                page += 1
+            else:
+                if successful_deletions == 0:
+                    page += 1
+                else:
+                    if new_items_processed == 0:
+                        self.logger.debug("No new unprocessed matches on this page. Stopping.")
+                        break
+
+        self.logger.info("Purge process completed.")
+        self.logger.info(
+            f"Summary - {'Would delete' if self.dry_run else 'Deleted'}: {stats['deleted']}, "
+            f"Skipped: {stats['skipped']}, Errors: {stats['errors']}"
+        )
+        return stats

slackctl-0.1.0.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.4
+Name: slackctl
+Version: 0.1.0
+Summary: A collection of handy CLI utilities for Slack (purging messages, exporting history, etc.)
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: requests>=2.31.0
+Requires-Dist: click>=8.1.7
+
+# slackctl
+
+cli tool to clear out your slack messages or export them to a neat dashboard.
+
+## setup
+
+### slack app permissions
+you need to build a quick slack app to get a token:
+1. head to https://api.slack.com/apps and create a new app from scratch.
+2. add these user scopes under oauth and permissions:
+   - channels:history
+   - groups:history
+   - chat:write
+   - search:read
+3. click install to workspace and copy the token starting with xoxp-.
+
+### install
+make sure your python venv is active, then run:
+```bash
+pip install -e .
+```
+
+## config
+save your credentials in a `.env` file so you don't have to keep pasting them:
+```env
+SLACK_TOKEN="xoxp-your-token-here"
+SLACK_CHANNEL="your-channel-id-here"
+```
+
+## commands
+
+### purge
+deletes your messages from the target channel using slack's search api.
+
+dry run (safely checks what would get deleted):
+```bash
+slackctl purge
+```
+
+live run (actually deletes everything):
+```bash
+slackctl purge --no-dry-run
+```
+
+### export
+saves your message history to an offline html dashboard or raw data formats.
+
+build html dashboard:
+```bash
+slackctl export
+```
+
+other formats:
+```bash
+slackctl export --format markdown -o messages.md
+slackctl export --format json -o messages.json
+```

slackctl-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+slackctl/__init__.py,sha256=EgozVJyyk1jp16NC64d_jAXS-WVMJ2NuojkNG6BNyrA,91
+slackctl/cli.py,sha256=53W1cLfYJeHLC8Qy6E511CdmiyHOHgURj6GAKHPJYwg,7006
+slackctl/exporter.py,sha256=fkE9Mn2XQnSyFQXnwhjQ46Z7dqgevYRrQsyjPGgcndc,10043
+slackctl/purger.py,sha256=m_pY4m5RKYqyLHjogARmLZTZNvxkSDZW8sXCVlYe9jc,8015
+slackctl-0.1.0.dist-info/METADATA,sha256=HqPpgrkr1yoOCSCIU1zeCJT8gNw8ILApsZ8hVip0CbU,1506
+slackctl-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+slackctl-0.1.0.dist-info/entry_points.txt,sha256=mrtQJ6gCMMkZ7OxMCSe02asV83Ty5seDfXar887QtRo,85
+slackctl-0.1.0.dist-info/top_level.txt,sha256=QIwBVORwrdXnzq5pHeErvZFC20NDUe_bEtnacoFMHJo,9
+slackctl-0.1.0.dist-info/RECORD,,

slackctl-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

slackctl-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+slack-wipe = slackctl.cli:wipe_compat
+slackctl = slackctl.cli:main

slackctl-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+slackctl