@misterhuydo/sentinel 1.0.15 → 1.0.16

package/.cairn/.hint-lock

@@ -1 +1 @@
-2026-03-21T17:34:17.867Z
+2026-03-21T18:10:35.571Z

package/.cairn/session.json

@@ -1,6 +1,6 @@
 {
-  "message": "Auto-checkpoint at 2026-03-21T17:41:53.418Z",
-  "checkpoint_at": "2026-03-21T17:41:53.419Z",
+  "message": "Auto-checkpoint at 2026-03-21T17:52:09.310Z",
+  "checkpoint_at": "2026-03-21T17:52:09.311Z",
   "active_files": [],
   "notes": [],
   "mtime_snapshot": {}

package/package.json

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

package/python/sentinel/config_loader.py

@@ -58,6 +58,7 @@ class SentinelConfig:
     upgrade_check_hours: int = 6     # hours between npm upgrade checks
     slack_bot_token: str = ""        # xoxb-...
     slack_app_token: str = ""        # xapp-... (Socket Mode)
+    slack_channel: str = ""          # optional: restrict to one channel ID or name
 
 
 @dataclass
@@ -149,6 +150,7 @@ class ConfigLoader:
         c.upgrade_check_hours = int(d.get("UPGRADE_CHECK_HOURS", 6))
         c.slack_bot_token = d.get("SLACK_BOT_TOKEN", "")
         c.slack_app_token = d.get("SLACK_APP_TOKEN", "")
+        c.slack_channel = d.get("SLACK_CHANNEL", "")
         self.sentinel = c
 
     def _load_log_sources(self):

package/python/sentinel/slack_bot.py

@@ -1,228 +1,261 @@
-"""
-slack_bot.py — Slack integration for Sentinel Boss.
-
-One DevOps member is handled at a time per Sentinel instance.
-Others are queued and notified of their position. When the current
-session finishes, the next person is picked up automatically.
-
-Setup (api.slack.com):
-  1. Create a Slack App → Enable Socket Mode → copy App-Level Token (xapp-...)
-  2. Add Bot Token Scopes: app_mentions:read, chat:write, im:history,
-     channels:history, users:read
-  3. Enable Events: app_mention, message.im, message.channels
-  4. Install to workspace → copy Bot Token (xoxb-...)
-  5. Add to sentinel.properties:
-       SLACK_BOT_TOKEN=xoxb-...
-       SLACK_APP_TOKEN=xapp-...
-"""
-
-import asyncio
-import logging
-from dataclasses import dataclass, field
-from typing import Optional
-
-from .sentinel_boss import handle_message
-
-logger = logging.getLogger(__name__)
-
-
-# ── Session and Queue ─────────────────────────────────────────────────────────
-
-@dataclass
-class _Session:
-    user_id:   str
-    user_name: str
-    channel:   str
-    history:   list = field(default_factory=list)
-
-
-class _Queue:
-    """
-    Global sequential queue for a Sentinel instance.
-    One member at a time; others wait.
-    """
-
-    def __init__(self):
-        self._lock:    asyncio.Lock          = asyncio.Lock()
-        self._active:  Optional[_Session]    = None
-        self._waiting: list[tuple[_Session, str]] = []   # (session, first_message)
-
-    async def try_activate(
-        self, user_id: str, user_name: str, channel: str
-    ) -> tuple[str, int, Optional[_Session]]:
-        """
-        Returns:
-          ('active',     0,   session)  — slot is free, session started
-          ('continuing', 0,   session)  — same user already has the slot
-          ('queued',     pos, None)     — added to wait queue at position pos
-        """
-        async with self._lock:
-            if self._active is None:
-                self._active = _Session(user_id, user_name, channel)
-                return "active", 0, self._active
-
-            if self._active.user_id == user_id:
-                return "continuing", 0, self._active
-
-            # Deduplicate — don't queue the same user twice
-            if not any(s.user_id == user_id for s, _ in self._waiting):
-                self._waiting.append((_Session(user_id, user_name, channel), ""))
-
-            pos = next(
-                i + 1
-                for i, (s, _) in enumerate(self._waiting)
-                if s.user_id == user_id
-            )
-            return "queued", pos, None
-
-    async def update_waiting_message(self, user_id: str, message: str):
-        """Overwrite the first message for a queued user (they may rephrase while waiting)."""
-        async with self._lock:
-            for i, (s, _) in enumerate(self._waiting):
-                if s.user_id == user_id:
-                    self._waiting[i] = (s, message)
-                    return
-
-    async def complete(self) -> Optional[tuple[_Session, str]]:
-        """Release the active slot. Returns (next_session, first_message) or None."""
-        async with self._lock:
-            prev = self._active
-            self._active = None
-            if self._waiting:
-                session, msg = self._waiting.pop(0)
-                self._active = session
-                return session, msg
-            return None
-
-    def active_user_name(self) -> Optional[str]:
-        return self._active.user_name if self._active else None
-
-
-_queue = _Queue()
-
-
-# ── Slack bot ─────────────────────────────────────────────────────────────────
-
-async def run_slack_bot(cfg_loader, store) -> None:
-    """
-    Start Slack Bolt in Socket Mode as an asyncio background task.
-    Exits silently if tokens are missing or slack-bolt is not installed.
-    """
-    try:
-        from slack_bolt.async_app import AsyncApp
-        from slack_bolt.adapter.socket_mode.async_handler import AsyncSocketModeHandler
-    except ImportError:
-        logger.warning(
-            "slack-bolt not installed — Slack bot disabled. "
-            "Run: pip install slack-bolt"
-        )
-        return
-
-    cfg = cfg_loader.sentinel
-    if not cfg.slack_bot_token or not cfg.slack_app_token:
-        logger.info("SLACK_BOT_TOKEN / SLACK_APP_TOKEN not set — Slack bot disabled")
-        return
-
-    app = AsyncApp(token=cfg.slack_bot_token)
-
-    # ── Event handlers ────────────────────────────────────────────────────────
-
-    @app.event("app_mention")
-    async def on_mention(event, client):
-        await _dispatch(event, client, cfg_loader, store)
-
-    @app.event("message")
-    async def on_message(event, client):
-        # Handle DMs only (channel_type == "im"); ignore bot messages
-        if event.get("channel_type") == "im" and not event.get("bot_id"):
-            await _dispatch(event, client, cfg_loader, store)
-
-    # ── Start ─────────────────────────────────────────────────────────────────
-
-    handler = AsyncSocketModeHandler(app, cfg.slack_app_token)
-    logger.info("Sentinel Boss connected to Slack (Socket Mode)")
-    await handler.start_async()
-
-
-# ── Dispatcher ────────────────────────────────────────────────────────────────
-
-async def _dispatch(event: dict, client, cfg_loader, store) -> None:
-    user_id = event.get("user", "")
-    channel = event.get("channel", "")
-    text    = _strip_mention(event.get("text", "")).strip()
-
-    if not text:
-        return
-
-    user_name = await _resolve_name(client, user_id)
-
-    status, pos, session = await _queue.try_activate(user_id, user_name, channel)
-
-    if status == "queued":
-        await _queue.update_waiting_message(user_id, text)
-        active = _queue.active_user_name() or "someone"
-        await _post(client, channel,
-            f"I'm working with *{active}* right now. "
-            f"You're *#{pos}* in the queue — I'll come to you when done. :hourglass_flowing_sand:"
-        )
-        return
-
-    # Active or continuing — process the turn
-    await _run_turn(session, text, client, cfg_loader, store)
-
-
-# ── Turn processor ────────────────────────────────────────────────────────────
-
-async def _run_turn(session: _Session, message: str, client, cfg_loader, store) -> None:
-    channel = session.channel
-
-    # Typing indicator
-    await _post(client, channel, "_thinking..._")
-
-    try:
-        reply, is_done = await handle_message(
-            message, session.history, cfg_loader, store
-        )
-    except Exception as e:
-        logger.exception("Sentinel Boss error: %s", e)
-        await _post(client, channel, f":warning: Unhandled error: {e}")
-        is_done = True
-
-    await _post(client, channel, reply)
-
-    if is_done:
-        next_item = await _queue.complete()
-        if next_item:
-            next_session, first_msg = next_item
-            await _post(
-                client, channel,
-                f":white_check_mark: Done with *{session.user_name}*. "
-                f"<@{next_session.user_id}> — you're up!"
-            )
-            if first_msg:
-                # Process their first message immediately
-                await _run_turn(next_session, first_msg, client, cfg_loader, store)
-
-
-# ── Helpers ───────────────────────────────────────────────────────────────────
-
-async def _post(client, channel: str, text: str) -> None:
-    try:
-        await client.chat_postMessage(channel=channel, text=text)
-    except Exception as e:
-        logger.warning("Slack post failed: %s", e)
-
-
-async def _resolve_name(client, user_id: str) -> str:
-    try:
-        info = await client.users_info(user=user_id)
-        profile = info["user"]["profile"]
-        return profile.get("display_name") or profile.get("real_name") or user_id
-    except Exception:
-        return user_id
-
-
-def _strip_mention(text: str) -> str:
-    """Remove leading <@BOTID> mention from message text."""
-    import re
-    return re.sub(r"^<@[A-Z0-9]+>\s*", "", text)
+"""
+slack_bot.py — Slack integration for Sentinel Boss.
+
+One DevOps member is handled at a time per Sentinel instance.
+Others are queued and notified of their position. When the current
+session finishes, the next person is picked up automatically.
+
+Setup (api.slack.com):
+  1. Create a Slack App → Enable Socket Mode → copy App-Level Token (xapp-...)
+  2. Add Bot Token Scopes: app_mentions:read, chat:write, im:history,
+     channels:history, users:read
+  3. Enable Events: app_mention, message.im, message.channels
+  4. Install to workspace → copy Bot Token (xoxb-...)
+  5. Add to sentinel.properties:
+       SLACK_BOT_TOKEN=xoxb-...
+       SLACK_APP_TOKEN=xapp-...
+"""
+
+import asyncio
+import logging
+from dataclasses import dataclass, field
+from typing import Optional
+
+from .sentinel_boss import handle_message
+
+logger = logging.getLogger(__name__)
+
+
+# ── Session and Queue ─────────────────────────────────────────────────────────
+
+@dataclass
+class _Session:
+    user_id:   str
+    user_name: str
+    channel:   str
+    history:   list = field(default_factory=list)
+
+
+class _Queue:
+    """
+    Global sequential queue for a Sentinel instance.
+    One member at a time; others wait.
+    """
+
+    def __init__(self):
+        self._lock:    asyncio.Lock          = asyncio.Lock()
+        self._active:  Optional[_Session]    = None
+        self._waiting: list[tuple[_Session, str]] = []   # (session, first_message)
+
+    async def try_activate(
+        self, user_id: str, user_name: str, channel: str
+    ) -> tuple[str, int, Optional[_Session]]:
+        """
+        Returns:
+          ('active',     0,   session)  — slot is free, session started
+          ('continuing', 0,   session)  — same user already has the slot
+          ('queued',     pos, None)     — added to wait queue at position pos
+        """
+        async with self._lock:
+            if self._active is None:
+                self._active = _Session(user_id, user_name, channel)
+                return "active", 0, self._active
+
+            if self._active.user_id == user_id:
+                return "continuing", 0, self._active
+
+            # Deduplicate — don't queue the same user twice
+            if not any(s.user_id == user_id for s, _ in self._waiting):
+                self._waiting.append((_Session(user_id, user_name, channel), ""))
+
+            pos = next(
+                i + 1
+                for i, (s, _) in enumerate(self._waiting)
+                if s.user_id == user_id
+            )
+            return "queued", pos, None
+
+    async def update_waiting_message(self, user_id: str, message: str):
+        """Overwrite the first message for a queued user (they may rephrase while waiting)."""
+        async with self._lock:
+            for i, (s, _) in enumerate(self._waiting):
+                if s.user_id == user_id:
+                    self._waiting[i] = (s, message)
+                    return
+
+    async def complete(self) -> Optional[tuple[_Session, str]]:
+        """Release the active slot. Returns (next_session, first_message) or None."""
+        async with self._lock:
+            prev = self._active
+            self._active = None
+            if self._waiting:
+                session, msg = self._waiting.pop(0)
+                self._active = session
+                return session, msg
+            return None
+
+    def active_user_name(self) -> Optional[str]:
+        return self._active.user_name if self._active else None
+
+
+_queue = _Queue()
+
+
+# ── Slack bot ─────────────────────────────────────────────────────────────────
+
+async def run_slack_bot(cfg_loader, store) -> None:
+    """
+    Start Slack Bolt in Socket Mode as an asyncio background task.
+    Exits silently if tokens are missing or slack-bolt is not installed.
+    """
+    try:
+        from slack_bolt.async_app import AsyncApp
+        from slack_bolt.adapter.socket_mode.async_handler import AsyncSocketModeHandler
+    except ImportError:
+        logger.warning(
+            "slack-bolt not installed — Slack bot disabled. "
+            "Run: pip install slack-bolt"
+        )
+        return
+
+    cfg = cfg_loader.sentinel
+    if not cfg.slack_bot_token or not cfg.slack_app_token:
+        logger.info("SLACK_BOT_TOKEN / SLACK_APP_TOKEN not set — Slack bot disabled")
+        return
+
+    if cfg.slack_channel:
+        logger.info("Sentinel Boss restricted to channel: %s", cfg.slack_channel)
+
+    app = AsyncApp(token=cfg.slack_bot_token)
+
+    # ── Channel resolver — converts #name to ID lazily on first event ─────────
+    _allowed_id: list = []   # single-element list used as mutable cell
+
+    async def _resolve_allowed(client):
+        raw = cfg.slack_channel.lstrip("#")
+        if not raw:
+            return
+        # Already a Slack channel ID (e.g. C01AB2CD3EF)
+        if raw.upper().startswith("C") and len(raw) >= 9:
+            _allowed_id.append(raw.upper())
+            return
+        try:
+            resp = await client.conversations_list(
+                types="public_channel,private_channel", limit=1000
+            )
+            for ch in (resp.get("channels") or []):
+                if ch.get("name") == raw:
+                    _allowed_id.append(ch["id"])
+                    logger.info("Boss channel resolved: #%s → %s", raw, ch["id"])
+                    return
+            logger.warning("SLACK_CHANNEL '%s' not found — responding everywhere", cfg.slack_channel)
+        except Exception as e:
+            logger.warning("Could not resolve SLACK_CHANNEL '%s': %s", cfg.slack_channel, e)
+
+    def _allowed(channel: str) -> bool:
+        return not _allowed_id or channel in _allowed_id
+
+    # ── Event handlers ────────────────────────────────────────────────────────
+
+    @app.event("app_mention")
+    async def on_mention(event, client):
+        if cfg.slack_channel and not _allowed_id:
+            await _resolve_allowed(client)
+        if _allowed(event.get("channel", "")):
+            await _dispatch(event, client, cfg_loader, store)
+
+    @app.event("message")
+    async def on_message(event, client):
+        # DMs are always allowed regardless of SLACK_CHANNEL restriction
+        if event.get("channel_type") == "im" and not event.get("bot_id"):
+            await _dispatch(event, client, cfg_loader, store)
+
+    # ── Start ─────────────────────────────────────────────────────────────────
+
+    handler = AsyncSocketModeHandler(app, cfg.slack_app_token)
+    logger.info("Sentinel Boss connected to Slack (Socket Mode)")
+    await handler.start_async()
+
+
+# ── Dispatcher ────────────────────────────────────────────────────────────────
+
+async def _dispatch(event: dict, client, cfg_loader, store) -> None:
+    user_id = event.get("user", "")
+    channel = event.get("channel", "")
+    text    = _strip_mention(event.get("text", "")).strip()
+
+    if not text:
+        return
+
+    user_name = await _resolve_name(client, user_id)
+
+    status, pos, session = await _queue.try_activate(user_id, user_name, channel)
+
+    if status == "queued":
+        await _queue.update_waiting_message(user_id, text)
+        active = _queue.active_user_name() or "someone"
+        await _post(client, channel,
+            f"I'm working with *{active}* right now. "
+            f"You're *#{pos}* in the queue — I'll come to you when done. :hourglass_flowing_sand:"
+        )
+        return
+
+    # Active or continuing — process the turn
+    await _run_turn(session, text, client, cfg_loader, store)
+
+
+# ── Turn processor ────────────────────────────────────────────────────────────
+
+async def _run_turn(session: _Session, message: str, client, cfg_loader, store) -> None:
+    channel = session.channel
+
+    # Typing indicator
+    await _post(client, channel, "_thinking..._")
+
+    try:
+        reply, is_done = await handle_message(
+            message, session.history, cfg_loader, store
+        )
+    except Exception as e:
+        logger.exception("Sentinel Boss error: %s", e)
+        await _post(client, channel, f":warning: Unhandled error: {e}")
+        is_done = True
+
+    await _post(client, channel, reply)
+
+    if is_done:
+        next_item = await _queue.complete()
+        if next_item:
+            next_session, first_msg = next_item
+            await _post(
+                client, channel,
+                f":white_check_mark: Done with *{session.user_name}*. "
+                f"<@{next_session.user_id}> — you're up!"
+            )
+            if first_msg:
+                # Process their first message immediately
+                await _run_turn(next_session, first_msg, client, cfg_loader, store)
+
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
+
+async def _post(client, channel: str, text: str) -> None:
+    try:
+        await client.chat_postMessage(channel=channel, text=text)
+    except Exception as e:
+        logger.warning("Slack post failed: %s", e)
+
+
+async def _resolve_name(client, user_id: str) -> str:
+    try:
+        info = await client.users_info(user=user_id)
+        profile = info["user"]["profile"]
+        return profile.get("display_name") or profile.get("real_name") or user_id
+    except Exception:
+        return user_id
+
+
+def _strip_mention(text: str) -> str:
+    """Remove leading <@BOTID> mention from message text."""
+    import re
+    return re.sub(r"^<@[A-Z0-9]+>\s*", "", text)

package/templates/sentinel.properties

@@ -25,3 +25,7 @@ WORKSPACE_DIR=./workspace
 # Then install to workspace and paste both tokens here.
 # SLACK_BOT_TOKEN=xoxb-...
 # SLACK_APP_TOKEN=xapp-...
+# Restrict Sentinel Boss to one channel (optional — omit to allow all channels + DMs)
+# Use the channel name (e.g. devops-sentinel) or the Slack channel ID (e.g. C01AB2CD3EF)
+# Note: requires conversations:read scope on the Slack App if using channel name
+# SLACK_CHANNEL=devops-sentinel