@misterhuydo/sentinel 1.0.93 → 1.0.95

package/.cairn/.hint-lock

@@ -1 +1 @@
-2026-03-23T06:43:35.264Z
+2026-03-23T07:27:36.554Z

package/.cairn/session.json

@@ -1,6 +1,6 @@
 {
-  "message": "Auto-checkpoint at 2026-03-23T06:29:40.508Z",
-  "checkpoint_at": "2026-03-23T06:29:40.509Z",
+  "message": "Auto-checkpoint at 2026-03-23T07:27:43.568Z",
+  "checkpoint_at": "2026-03-23T07:27:43.570Z",
   "active_files": [],
   "notes": [],
   "mtime_snapshot": {}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@misterhuydo/sentinel",
-  "version": "1.0.93",
+  "version": "1.0.95",
   "description": "Sentinel — Autonomous DevOps Agent installer and manager",
   "bin": {
     "sentinel": "./bin/sentinel.js"

package/python/sentinel/cairn_client.py

@@ -19,12 +19,20 @@ logger = logging.getLogger(__name__)
 CAIRN_BIN = "cairn"
 
 
-def ensure_installed() -> bool:
+def get_version() -> str:
+    """Return the installed cairn version string, or '' if not found."""
     try:
-        subprocess.run([CAIRN_BIN, "--version"], capture_output=True, text=True, timeout=10)
-        return True
+        r = subprocess.run([CAIRN_BIN, "--version"], capture_output=True, text=True, timeout=10)
+        return r.stdout.strip() or r.stderr.strip()
     except FileNotFoundError:
-        pass
+        return ""
+
+
+def ensure_installed() -> bool:
+    version = get_version()
+    if version:
+        logger.info("cairn-mcp %s", version)
+        return True
     logger.warning("cairn-mcp not found. Run: npm install -g @misterhuydo/cairn-mcp")
     return False
 

package/python/sentinel/config_loader.py

@@ -62,6 +62,7 @@ class SentinelConfig:
     slack_channel: str = ""          # optional: restrict to one channel ID or name
     slack_watch_bot_ids: list[str] = field(default_factory=list)   # pre-configured bot IDs to watch passively
     slack_allowed_users: list[str] = field(default_factory=list)  # if set, only these Slack user IDs can talk to Boss
+    slack_admin_users: list[str] = field(default_factory=list)   # subset of allowed users with admin privileges
     project_name: str = ""           # optional: friendly name used by Sentinel Boss (e.g. "1881")
     # Auth strategy:
     #   ANTHROPIC_API_KEY  — used by Sentinel Boss conversation (structured tools, cheap per-token)
@@ -162,6 +163,7 @@ class ConfigLoader:
         c.slack_channel = d.get("SLACK_CHANNEL", "")
         c.slack_watch_bot_ids = _csv(d.get("SLACK_WATCH_BOT_IDS", ""))
         c.slack_allowed_users = _csv(d.get("SLACK_ALLOWED_USERS", ""))
+        c.slack_admin_users = _csv(d.get("SLACK_ADMIN_USERS", ""))
         c.project_name = d.get("PROJECT_NAME", "")
         c.claude_pro_for_tasks = d.get("CLAUDE_PRO_FOR_TASKS", "true").lower() != "false"
         self.sentinel = c

package/python/sentinel/sentinel_boss.py

@@ -148,19 +148,26 @@ reply with a short summary grouped by category:
 • `pull_repo` — git pull on managed application repos — "pull latest code"
 • `pull_config` — git pull on Sentinel config dirs — "pull config for elprint"
 
+*File sharing*
+• `post_file` — upload a file to Slack — "give me that as a file", "export the log", "send me the diff"
+
+*Personal*
+• `my_stats` — your activity: issues submitted, fixes, conversation history — "my stats"
+• `clear_my_history` — wipe your conversation history and start fresh — "clear my history"
+
 *Slack bot watching*
-• `watch_bot` — register a Slack bot for passive monitoring; its messages are auto-queued as issues — "listen to @alertbot"
-• `unwatch_bot` — stop monitoring a bot — "stop watching @errorbot"
 • `list_watched_bots` — show all bots currently being monitored — "which bots are you watching?"
 
-*Project control*
+*Admin* (SLACK_ADMIN_USERS if configured, otherwise all allowed users)
+• `watch_bot` — register a Slack bot for passive monitoring; its messages become issues — "listen to @alertbot"
+• `unwatch_bot` — stop monitoring a bot — "stop watching @errorbot"
 • `restart_project` — stop + restart a Sentinel monitoring instance (not the app) — "restart sentinel for 1881"
-
-*Self-management*
-• `upgrade_sentinel` — git pull + pip install + restart — "upgrade sentinel", "update yourself"
-
-*File sharing*
-• `post_file` — upload a file to Slack — "give me that as a file", "export the log", "send me the diff"
+• `upgrade_sentinel` — pull latest Sentinel release and restart — "upgrade sentinel"
+• `list_all_users` — all Slack users who have talked to Sentinel + activity summary
+• `clear_user_history` — wipe a specific user's conversation history
+• `reset_fingerprint` — clear the 24h fix lock so Sentinel retries an error
+• `list_all_errors` — full unfiltered error database
+• `export_db` — dump full Sentinel state as a downloadable file
 
 Tone: direct, professional, like a senior engineer who owns the system.
 Don't pad responses. Don't say "Great question!" or "Certainly!".
@@ -588,6 +595,77 @@ _TOOLS = [
             "required": ["content", "filename"],
         },
     },
+    {
+        "name": "list_all_users",
+        "description": (
+            "ADMIN ONLY. List all Slack users who have ever talked to Sentinel, "
+            "with their issue count and conversation message count. "
+            "e.g. 'list all users', 'who has talked to you?', 'show user activity'"
+        ),
+        "input_schema": {"type": "object", "properties": {}},
+    },
+    {
+        "name": "clear_user_history",
+        "description": (
+            "ADMIN ONLY. Clear the conversation history for a specific Slack user. "
+            "e.g. 'clear history for huy', 'reset bob's conversation'"
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "user_id": {
+                    "type": "string",
+                    "description": "Slack user ID to clear (e.g. U01AB2CD3EF)",
+                },
+            },
+            "required": ["user_id"],
+        },
+    },
+    {
+        "name": "reset_fingerprint",
+        "description": (
+            "ADMIN ONLY. Remove the 24h fix lock for an error fingerprint so Sentinel will retry it "
+            "on the next poll cycle. Use when a fix attempt failed and you want to force a retry. "
+            "e.g. 'retry fix abc123', 'reset fingerprint abc123de', 'let Sentinel try that error again'"
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "fingerprint": {
+                    "type": "string",
+                    "description": "Error fingerprint hash (8+ hex chars, from get_fix_details or list_all_errors)",
+                },
+            },
+            "required": ["fingerprint"],
+        },
+    },
+    {
+        "name": "list_all_errors",
+        "description": (
+            "ADMIN ONLY. Return the full unfiltered error database — all fingerprints, counts, "
+            "sources, and last-seen times. "
+            "e.g. 'show all errors', 'full error list', 'dump the error DB'"
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "hours": {
+                    "type": "integer",
+                    "description": "Limit to errors seen in the last N hours (0 = all time)",
+                    "default": 0,
+                },
+            },
+        },
+    },
+    {
+        "name": "export_db",
+        "description": (
+            "ADMIN ONLY. Export the full Sentinel state (errors, fixes, PRs, users) as a "
+            "downloadable text file posted to Slack. "
+            "e.g. 'export the DB', 'download state', 'give me a full report file'"
+        ),
+        "input_schema": {"type": "object", "properties": {}},
+    },
 ]
 
 
@@ -654,7 +732,7 @@ def _git_pull(path: Path) -> dict:
 
 # ── Tool execution ────────────────────────────────────────────────────────────
 
-async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=None, user_id: str = "", channel: str = "") -> str:
+async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=None, user_id: str = "", channel: str = "", is_admin: bool = False) -> str:
     if name == "get_status":
         hours = int(inputs.get("hours", 24))
         errors = store.get_recent_errors(hours)
@@ -999,6 +1077,8 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
         return json.dumps({"fetched": len(results), "results": results})
 
     if name == "watch_bot":
+        if not is_admin:
+            return json.dumps({"error": "Admin access required to register bots for monitoring."})
         user_ids    = inputs.get("user_ids", [])
         project_arg = inputs.get("project", "").strip()
         if not user_ids:
@@ -1055,6 +1135,8 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
         return json.dumps({"results": results})
 
     if name == "unwatch_bot":
+        if not is_admin:
+            return json.dumps({"error": "Admin access required to remove bots from monitoring."})
         user_ids = inputs.get("user_ids", [])
         if not user_ids:
             return json.dumps({"error": "No user_ids provided"})
@@ -1082,6 +1164,8 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
         })
 
     if name == "upgrade_sentinel":
+        if not is_admin:
+            return json.dumps({"error": "Admin access required to upgrade Sentinel."})
         import threading
 
         # Sentinel is installed via npm — use `sentinel upgrade` which handles
@@ -1183,6 +1267,8 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
         return json.dumps({"project": target, "repos_queried": len(results), "results": results})
 
     if name == "restart_project":
+        if not is_admin:
+            return json.dumps({"error": "Admin access required to restart a project."})
         project_arg = inputs.get("project", "").lower()
         dirs = _find_project_dirs(project_arg)
         if not dirs:
@@ -1340,6 +1426,72 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
                 "note":    "Your conversation history has been wiped. Next session starts fresh. [DONE]",
             })
         return json.dumps({"error": "cannot determine user — not clearing"})
+
+    # ── Admin-only tools ──────────────────────────────────────────────────────
+    _ADMIN_TOOLS = {"list_all_users", "clear_user_history", "reset_fingerprint", "list_all_errors", "export_db"}
+    if name in _ADMIN_TOOLS:
+        if not is_admin:
+            return json.dumps({"error": "Admin access required. You are not in SLACK_ADMIN_USERS."})
+
+        if name == "list_all_users":
+            stats = store.get_all_user_stats()
+            return json.dumps({"users": stats, "total": len(stats)})
+
+        if name == "clear_user_history":
+            target = inputs.get("target_user_id", "").strip()
+            if not target:
+                return json.dumps({"error": "target_user_id is required"})
+            store.save_conversation(target, [])
+            display = store.get_user_name(target)
+            logger.info("Boss admin: cleared history for user %s (%s) by admin %s", target, display, user_id)
+            return json.dumps({"status": "cleared", "target_user_id": target, "display_name": display})
+
+        if name == "reset_fingerprint":
+            fp = inputs.get("fingerprint", "").strip()
+            if not fp:
+                return json.dumps({"error": "fingerprint is required"})
+            found = store.reset_fingerprint(fp)
+            logger.info("Boss admin: reset fingerprint %s by admin %s (found=%s)", fp, user_id, found)
+            return json.dumps({"status": "reset" if found else "not_found", "fingerprint": fp,
+                               "note": "Sentinel will retry this error on the next poll." if found else "No fix record found for this fingerprint."})
+
+        if name == "list_all_errors":
+            hours = int(inputs.get("hours", 0))
+            errors = store.get_all_errors(hours)
+            return json.dumps({"errors": errors[:100], "total": len(errors),
+                               "window_hours": hours or "all time"})
+
+        if name == "export_db":
+            if not slack_client or not channel:
+                return json.dumps({"error": "No Slack channel context — cannot upload file"})
+            try:
+                import sqlite3 as _sq
+                import io as _io
+                lines = []
+                with _sq.connect(store.db_path) as _db:
+                    for tbl in ["errors", "fixes", "reports", "slack_users", "conversations", "submitted_issues"]:
+                        try:
+                            rows = _db.execute(f"SELECT * FROM {tbl}").fetchall()  # noqa: S608
+                            cols = [d[0] for d in _db.execute(f"SELECT * FROM {tbl} LIMIT 0").description]  # noqa: S608
+                            lines.append(f"=== {tbl} ({len(rows)} rows) ===")
+                            lines.append("\t".join(cols))
+                            for row in rows:
+                                lines.append("\t".join(str(v) if v is not None else "" for v in row))
+                            lines.append("")
+                        except Exception:
+                            lines.append(f"=== {tbl} (unavailable) ===\n")
+                content = "\n".join(lines)
+                await slack_client.files_upload_v2(
+                    channel=channel,
+                    content=content,
+                    filename="sentinel-db-export.tsv",
+                    title="Sentinel DB Export",
+                )
+                logger.info("Boss admin: exported DB (%d bytes) by admin %s", len(content), user_id)
+                return json.dumps({"ok": True, "bytes": len(content)})
+            except Exception as e:
+                return json.dumps({"error": str(e)})
+
     return json.dumps({"error": f"unknown tool: {name}"})
 
 
@@ -1404,6 +1556,7 @@ async def _handle_with_cli(
     user_name: str = "",
     user_id: str = "",
     attachments: list | None = None,
+    is_admin: bool = False,
 ) -> tuple[str, bool]:
     """Fallback: use `claude --print` for users without an Anthropic API key."""
     status_json = await _run_tool("get_status", {"hours": 24}, cfg_loader, store)
@@ -1450,6 +1603,7 @@ async def _handle_with_cli(
         + f"\nSentinel status: {'⏸ PAUSED' if paused else '▶ RUNNING'}"
         + f"\nManaged repos: {', '.join(repos) if repos else '(none configured)'}"
         + (f"\nLog sources: {', '.join(log_sources)}" if log_sources else "")
+        + f"\nAdmin access for this user: {'YES — admin tools are available' if is_admin else 'NO — admin tools will be refused'}"
         + f"\n\nCurrent status (last 24 h):\n{status_json}"
         + f"\n\nOpen PRs:\n{prs_json}"
         + (f"\n\nLog search results:\n{search_json}" if search_json else "")
@@ -1529,6 +1683,7 @@ async def _handle_with_api(
     user_id: str = "",
     attachments: list | None = None,
     channel: str = "",
+    is_admin: bool = False,
 ) -> tuple[str, bool]:
     import anthropic
 
@@ -1554,6 +1709,7 @@ async def _handle_with_api(
         + f"\nManaged repos: {', '.join(repos) if repos else '(none configured)'}"
         + (f"\nLog sources: {', '.join(log_sources)}" if log_sources else "")
         + (f"\nKnown projects in workspace: {', '.join(known_projects)}" if known_projects else "")
+        + f"\nAdmin access for this user: {'YES — admin tools are available' if is_admin else 'NO — admin tools will be refused'}"
     )
 
     # Build user content — include attachment blocks if any
@@ -1595,7 +1751,7 @@ async def _handle_with_api(
         messages.append({"role": "assistant", "content": response.content})
         tool_results = []
         for tc in tool_blocks:
-            result = await _run_tool(tc.name, tc.input, cfg_loader, store, slack_client=slack_client, user_id=user_id, channel=channel)
+            result = await _run_tool(tc.name, tc.input, cfg_loader, store, slack_client=slack_client, user_id=user_id, channel=channel, is_admin=is_admin)
             logger.info("Boss tool: %s(%s) → %s", tc.name, tc.input, result[:120])
             tool_results.append({
                 "type":        "tool_result",
@@ -1617,6 +1773,7 @@ async def handle_message(
     user_id: str = "",
     attachments: list | None = None,
     channel: str = "",
+    is_admin: bool = False,
 ) -> tuple[str, bool]:
     """
     Process one user message through the Sentinel Boss (Claude with tool use).
@@ -1639,6 +1796,7 @@ async def handle_message(
             return await _handle_with_api(
                 message, history, cfg_loader, store, slack_client=slack_client,
                 user_name=user_name, user_id=user_id, attachments=attachments, channel=channel,
+                is_admin=is_admin,
             )
         except Exception as api_err:
             err_str = str(api_err)
@@ -1653,7 +1811,7 @@ async def handle_message(
     # 2nd priority: Claude Pro / OAuth via CLI (limited tools but no API key needed)
     cli_reply, cli_done = await _handle_with_cli(
         message, history, cfg_loader, store, slack_client=slack_client, user_name=user_name,
-        user_id=user_id, attachments=attachments,
+        user_id=user_id, attachments=attachments, is_admin=is_admin,
     )
     if not cli_reply.startswith(":warning:"):
         return cli_reply, cli_done

package/python/sentinel/slack_bot.py

@@ -344,6 +344,8 @@ async def _dispatch(event: dict, client, cfg_loader, store) -> None:
     user_name = await _resolve_name(client, user_id)
     store.upsert_user(user_id, user_name)
     session   = await _get_or_create_session(user_id, user_name, channel)
+    admin_users = cfg_loader.sentinel.slack_admin_users or []
+    is_admin    = (not admin_users) or (user_id in admin_users)
 
     if session.busy:
         # Still processing a previous turn from this user — drop the duplicate
@@ -358,14 +360,14 @@ async def _dispatch(event: dict, client, cfg_loader, store) -> None:
         if attachments:
             logger.info("Boss: %d attachment(s) from %s", len(attachments), user_id)
 
-    await _run_turn(session, text, client, cfg_loader, store, attachments=attachments)
+    await _run_turn(session, text, client, cfg_loader, store, attachments=attachments, is_admin=is_admin)
 
 
 # ── Turn processor ────────────────────────────────────────────────────────────
 
 _MAX_HISTORY_TURNS = 20   # keep last 20 exchanges (~40 messages) to stay well within context limits
 
-async def _run_turn(session: _Session, message: str, client, cfg_loader, store, attachments: list | None = None) -> None:
+async def _run_turn(session: _Session, message: str, client, cfg_loader, store, attachments: list | None = None, is_admin: bool = False) -> None:
     channel = session.channel
 
     # Load persisted history from DB on the first turn of a new session
@@ -391,6 +393,7 @@ async def _run_turn(session: _Session, message: str, client, cfg_loader, store,
             user_id=session.user_id,
             attachments=attachments or [],
             channel=channel,
+            is_admin=is_admin,
         )
     except Exception as e:
         logger.exception("Sentinel Boss error: %s", e)

package/python/sentinel/state_store.py

@@ -458,3 +458,42 @@ class StateStore:
             except Exception:
                 return []
         return []
+
+    # ── Admin operations ──────────────────────────────────────────────────────
+
+    def get_all_user_stats(self) -> list[dict]:
+        """Return activity summary for every known Slack user."""
+        users = self.get_all_users()  # {user_id: display_name}
+        result = []
+        for uid, name in users.items():
+            issues = self.get_submitted_issues(uid)
+            conv   = self.load_conversation(uid)
+            result.append({
+                "user_id":      uid,
+                "display_name": name,
+                "issues_submitted": len(issues),
+                "conversation_messages": len(conv),
+            })
+        return result
+
+    def reset_fingerprint(self, fingerprint: str) -> bool:
+        """Remove a fix record so Sentinel will retry the error on the next poll."""
+        with self._conn() as conn:
+            cur = conn.execute("DELETE FROM fixes WHERE fingerprint = ?", (fingerprint,))
+            conn.execute("UPDATE errors SET last_seen = NULL WHERE fingerprint = ?", (fingerprint,))
+        return cur.rowcount > 0
+
+    def get_all_errors(self, hours: int = 0) -> list[dict]:
+        """Return full unfiltered error list, optionally within a time window."""
+        with self._conn() as conn:
+            if hours:
+                rows = conn.execute(
+                    "SELECT * FROM errors WHERE last_seen >= datetime('now', ? || ' hours') "
+                    "ORDER BY last_seen DESC",
+                    (f"-{hours}",),
+                ).fetchall()
+            else:
+                rows = conn.execute(
+                    "SELECT * FROM errors ORDER BY last_seen DESC"
+                ).fetchall()
+        return [dict(r) for r in rows]

package/templates/workspace-sentinel.properties

@@ -68,3 +68,14 @@ CONFIG_POLL_INTERVAL=60
 # SLACK_BOT_TOKEN=xoxb-...
 # SLACK_APP_TOKEN=xapp-...
 # SLACK_CHANNEL=devops-sentinel
+#
+# Allowlist: if set, only these Slack user IDs can message Sentinel Boss.
+# Leave blank to allow everyone in the workspace.
+# Get user IDs from Slack: click profile → ⋯ → Copy member ID
+# SLACK_ALLOWED_USERS=U123ABC,U456DEF
+#
+# Admin users: a subset of allowed users with elevated privileges.
+# Admins can use: list_all_users, clear_user_history, reset_fingerprint,
+#                 list_all_errors, export_db
+# These are powerful operations — restrict to trusted team members.
+# SLACK_ADMIN_USERS=U123ABC