@misterhuydo/sentinel 1.5.36 → 1.5.37

package/package.json

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

package/python/scripts/fetch_log.sh

@@ -115,6 +115,10 @@ fetch_from_properties() {
 
   # Apply defaults for fetch parameters
   TAIL="${TAIL:-$DEFAULT_TAIL}"
+  # Env var override takes precedence over config file value (used by Boss fetch_logs tool)
+  if [[ -n "$SENTINEL_GREP_FILTER_OVERRIDE" ]]; then
+    GREP_FILTER="$SENTINEL_GREP_FILTER_OVERRIDE"
+  fi
   if [[ -z "$GREP_FILTER" ]]; then
     GREP_FILTER="$DEFAULT_GREP_FILTER"
   elif [[ "$GREP_FILTER" == "none" || "$GREP_FILTER" == "*" ]]; then

package/python/sentinel/__init__.py

@@ -1 +1 @@
-__version__ = "1.5.36"
+__version__ = "1.5.37"

package/python/sentinel/log_fetcher.py

@@ -119,7 +119,7 @@ def _find_props_file(src):
     return None
 
 
-def _fetch_ssh(src, cfg):
+def _fetch_ssh(src, cfg, grep_filter_override: str = ""):
     props_file = _find_props_file(src)
     if not props_file:
         raise FileNotFoundError(f"Properties file not found for {src.name}")
@@ -130,9 +130,13 @@ def _fetch_ssh(src, cfg):
     tmp_dir = workspace / f"_tmp_{src.name}"
     tmp_dir.mkdir(exist_ok=True)
 
+    env = {**os.environ.copy(), "OUTPUT_DIR": str(tmp_dir)}
+    if grep_filter_override:
+        env["SENTINEL_GREP_FILTER_OVERRIDE"] = grep_filter_override
+
     result = subprocess.run(
         ["bash", str(FETCH_LOG_SH), str(props_file)],
-        env={**os.environ.copy(), "OUTPUT_DIR": str(tmp_dir)},
+        env=env,
         capture_output=True,
         text=True,
         timeout=120,

package/python/sentinel/sentinel_boss.py

@@ -351,6 +351,12 @@ reply with a grouped summary like this:
 • `watch_bot` — register a bot for passive monitoring; its messages become issues
 • `unwatch_bot` — remove a bot from the watch list
 • `list_watched_bots` — show all monitored bots
+• `save_service_alias` — remember that a short service name (e.g. "STS") maps to a repo name.
+  Call this when:
+    – The user replies to a routing question with a repo name
+      (e.g. Sentinel asked "which repo is STS?" and user replies "Whydah-SecurityTokenService")
+    – The user explicitly says "STS is Whydah-SecurityTokenService" or "route STS to ..."
+  After saving, Sentinel automatically reprocesses any pending routing for that service.
 
 *File sharing*
 • `post_file` — upload any output as a Slack file (logs, diffs, reports)
@@ -1226,6 +1232,31 @@ _TOOLS = [
         ),
         "input_schema": {"type": "object", "properties": {}},
     },
+    {
+        "name": "save_service_alias",
+        "description": (
+            "Save a mapping from a short service name to the full repo name so Sentinel can "
+            "auto-route future bot alerts. Call this when: (1) the user replies to a routing "
+            "question with a repo name (e.g. Sentinel asked 'which repo is STS?' and user "
+            "replies 'Whydah-SecurityTokenService'), or (2) the user explicitly says "
+            "'STS is Whydah-SecurityTokenService' or 'route STS alerts to ...'. "
+            "After saving, also reprocess any pending routing for that service hint."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "service_name": {
+                    "type": "string",
+                    "description": "The short name used in bot reports (e.g. 'STS', 'SSOLWA', 'UAS')",
+                },
+                "repo_name": {
+                    "type": "string",
+                    "description": "The full repo name to route this service to (must match a configured repo)",
+                },
+            },
+            "required": ["service_name", "repo_name"],
+        },
+    },
     {
         "name": "upgrade_sentinel",
         "description": (
@@ -3044,7 +3075,7 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
             if tail_override:
                 env["TAIL"] = str(tail_override)
             if grep_override:
-                env["GREP_FILTER"] = grep_override
+                env["SENTINEL_GREP_FILTER_OVERRIDE"] = grep_override
 
             cmd = ["bash", str(script)]
             if debug:
@@ -3170,6 +3201,56 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
             ],
         })
 
+    if name == "save_service_alias":
+        service_name = inputs.get("service_name", "").strip()
+        repo_name    = inputs.get("repo_name", "").strip()
+        if not service_name or not repo_name:
+            return json.dumps({"error": "service_name and repo_name are required"})
+
+        # Validate repo_name against configured repos
+        known_repos = list(cfg_loader.repos.keys())
+        if repo_name not in cfg_loader.repos:
+            # Try case-insensitive match
+            matches = [r for r in known_repos if r.lower() == repo_name.lower()]
+            if matches:
+                repo_name = matches[0]
+            else:
+                return json.dumps({
+                    "error": f"'{repo_name}' does not match any configured repo.",
+                    "known_repos": known_repos,
+                })
+
+        store.save_service_alias(service_name, repo_name, added_by=user_id or "boss")
+
+        # Reprocess pending routings for this service hint
+        pending = store.resolve_pending_routing(service_name)
+        requeued = 0
+        if pending:
+            for row in pending:
+                idir = row.get("issues_dir") or str(Path(cfg_loader.sentinel.workspace_dir).parent / "issues")
+                issues_dir = Path(idir)
+                issues_dir.mkdir(parents=True, exist_ok=True)
+                ts_str  = datetime.now(timezone.utc).strftime("%Y%m%dT%H%M%S")
+                fp      = str(uuid.uuid4())[:8]
+                ifile   = issues_dir / f"bot-{ts_str}-{fp}.txt"
+                body    = row.get("content", "")
+                header  = f"TARGET_REPO: {repo_name}\n"
+                ifile.write_text(header + body, encoding="utf-8")
+                requeued += 1
+            logger.info("save_service_alias: requeued %d pending routings for %s → %s",
+                        requeued, service_name, repo_name)
+
+        return json.dumps({
+            "status":   "saved",
+            "alias":    f"{service_name} → {repo_name}",
+            "requeued": requeued,
+            "note":     (
+                f"Saved alias: '{service_name}' → '{repo_name}'. "
+                + (f"Re-queued {requeued} pending issue(s) for processing." if requeued else
+                   "No pending issues to requeue.")
+            ),
+        })
+
     if name == "upgrade_sentinel":
         if not is_admin:
             return json.dumps({"error": "upgrade is admin-only. Ask a Sentinel admin to perform the upgrade."})

package/python/sentinel/slack_bot.py

@@ -181,28 +181,40 @@ import uuid as _uuid
 from pathlib import Path as _Path
 
 
-def _infer_target_repo(text: str, repos: dict) -> str:
+def _infer_target_repo(text: str, repos: dict, store=None) -> str:
     """
     Try to infer a target repo from bot message content.
-    Looks for 'Service: <name>' or 'service: <name>' patterns and fuzzy-matches
-    the extracted name against known repo names. Returns the repo name on a unique
-    match, empty string if ambiguous or no match found.
+    Checks in order:
+      1. Saved aliases in DB (e.g. "STS" → "Whydah-SecurityTokenService")
+      2. Case-insensitive substring match against repo names
+    Returns the repo name on a unique match, empty string otherwise.
     """
     import re as _re
-    # Extract service hints: "Service: STS", "service: SSOLWA", etc.
     hints = _re.findall(r'(?i)service:\s*(\S+)', text)
-    # Also try class names: "Class: SomeService" — extract first word segment
     hints += _re.findall(r'(?i)class:\s*(\w+)', text)
 
     for hint in hints:
-        hint_lower = hint.lower().rstrip(".,:")
-        matches = [r for r in repos if hint_lower in r.lower()]
-        if len(matches) == 1:
-            return matches[0]
+        hint_clean = hint.rstrip(".,:")
+        # 1. Saved alias lookup
+        if store:
+            alias = store.get_service_alias(hint_clean)
+            if alias and alias in repos:
+                return alias
+        # 2. Case-insensitive substring match
+        sub_matches = [r for r in repos if hint_clean.lower() in r.lower()]
+        if len(sub_matches) == 1:
+            return sub_matches[0]
 
     return ""
 
 
+def _extract_service_hint(text: str) -> str:
+    """Extract the first 'Service: <name>' value from a bot message."""
+    import re as _re
+    m = _re.search(r'(?i)service:\s*(\S+)', text)
+    return m.group(1).rstrip(".,: ") if m else ""
+
+
 async def _handle_bot_message(event: dict, client, cfg_loader, store) -> None:
     """
     Called when a watched bot posts a message.
@@ -240,23 +252,40 @@ async def _handle_bot_message(event: dict, client, cfg_loader, store) -> None:
 
     # Auto-detect target_repo from message content when not pre-configured
     if not target_repo and hasattr(cfg_loader, "repos") and cfg_loader.repos:
-        target_repo = _infer_target_repo(text, cfg_loader.repos)
+        target_repo = _infer_target_repo(text, cfg_loader.repos, store=store)
         if not target_repo and len(cfg_loader.repos) > 1:
-            # Can't determine — ask in the channel where the bot posted
+            # Can't determine — ask in the channel and store as pending routing
             bot_name = (bot_info or {}).get("bot_name") or bot_id
+            service_hint = _extract_service_hint(text)
+            hint_label = f"`{service_hint}`" if service_hint else "this alert"
             repo_names = ", ".join(f"`{r}`" for r in sorted(cfg_loader.repos))
             try:
                 await client.chat_postMessage(
                     channel=channel,
                     text=(
-                        f":mag: I got an alert from *{bot_name}* but can't tell which repo to route it to.\n"
-                        f"Available repos: {repo_names}\n"
-                        f"Re-register with: `@Sentinel watch @{bot_name} for <repo-name>`"
+                        f":mag: Got an alert from *{bot_name}* — can't tell which repo to route {hint_label} to.\n"
+                        f"Reply with the repo name and I'll remember it for next time.\n"
+                        f"Available: {repo_names}\n\n"
+                        f"_{text[:300]}_"
                     ),
                 )
             except Exception as _e:
                 logger.warning("Bot watcher: could not post routing question: %s", _e)
-            return  # drop this message — don't queue an unroutable issue
+            # Store as pending so Boss can reprocess when user replies
+            if service_hint:
+                try:
+                    default_issues = str(_Path(cfg_loader.sentinel.workspace_dir).parent / "issues")
+                    store.add_pending_routing(
+                        service_hint=service_hint,
+                        bot_id=bot_id,
+                        channel=channel,
+                        ts=ts,
+                        content=text,
+                        issues_dir=default_issues,
+                    )
+                except Exception as _e:
+                    logger.warning("Bot watcher: could not store pending routing: %s", _e)
+            return  # drop this message until routing is resolved
 
     # Resolve the project issues directory
     workspace = _Path(cfg_loader.sentinel.workspace_dir).parent

package/python/sentinel/state_store.py

@@ -401,6 +401,81 @@ class StateStore:
                 (key, _now()),
             )
 
+    # ── Service name aliases (e.g. "STS" → "Whydah-SecurityTokenService") ───────
+
+    def _ensure_service_aliases_table(self, conn):
+        conn.execute(
+            "CREATE TABLE IF NOT EXISTS service_aliases "
+            "(service_name TEXT PRIMARY KEY, repo_name TEXT, added_by TEXT, added_at TEXT)"
+        )
+
+    def save_service_alias(self, service_name: str, repo_name: str, added_by: str = "boss") -> None:
+        with self._conn() as conn:
+            self._ensure_service_aliases_table(conn)
+            conn.execute(
+                "INSERT OR REPLACE INTO service_aliases (service_name, repo_name, added_by, added_at) "
+                "VALUES (?, ?, ?, ?)",
+                (service_name.strip(), repo_name.strip(), added_by, _now()),
+            )
+
+    def get_service_alias(self, service_name: str) -> str:
+        with self._conn() as conn:
+            self._ensure_service_aliases_table(conn)
+            row = conn.execute(
+                "SELECT repo_name FROM service_aliases WHERE service_name = ? COLLATE NOCASE",
+                (service_name.strip(),),
+            ).fetchone()
+            return row["repo_name"] if row else ""
+
+    def get_all_service_aliases(self) -> list[dict]:
+        with self._conn() as conn:
+            self._ensure_service_aliases_table(conn)
+            rows = conn.execute("SELECT * FROM service_aliases ORDER BY service_name").fetchall()
+            return [dict(r) for r in rows]
+
+    # ── Pending bot-message routing questions ─────────────────────────────────
+
+    def _ensure_pending_routings_table(self, conn):
+        conn.execute(
+            "CREATE TABLE IF NOT EXISTS pending_routings "
+            "(id INTEGER PRIMARY KEY AUTOINCREMENT, service_hint TEXT, bot_id TEXT, "
+            "channel TEXT, ts TEXT, content TEXT, issues_dir TEXT, asked_at TEXT)"
+        )
+
+    def add_pending_routing(self, service_hint: str, bot_id: str, channel: str,
+                             ts: str, content: str, issues_dir: str) -> None:
+        with self._conn() as conn:
+            self._ensure_pending_routings_table(conn)
+            conn.execute(
+                "INSERT INTO pending_routings "
+                "(service_hint, bot_id, channel, ts, content, issues_dir, asked_at) "
+                "VALUES (?, ?, ?, ?, ?, ?, ?)",
+                (service_hint, bot_id, channel, ts, content, issues_dir, _now()),
+            )
+
+    def get_pending_routings(self) -> list[dict]:
+        with self._conn() as conn:
+            self._ensure_pending_routings_table(conn)
+            rows = conn.execute(
+                "SELECT * FROM pending_routings ORDER BY asked_at DESC LIMIT 20"
+            ).fetchall()
+            return [dict(r) for r in rows]
+
+    def resolve_pending_routing(self, service_hint: str) -> list[dict]:
+        """Return and delete all pending routings for a given service hint."""
+        with self._conn() as conn:
+            self._ensure_pending_routings_table(conn)
+            rows = conn.execute(
+                "SELECT * FROM pending_routings WHERE service_hint = ? COLLATE NOCASE",
+                (service_hint,),
+            ).fetchall()
+            result = [dict(r) for r in rows]
+            conn.execute(
+                "DELETE FROM pending_routings WHERE service_hint = ? COLLATE NOCASE",
+                (service_hint,),
+            )
+            return result
+
     # ── Watched bots (Slack passive monitor) ─────────────────────────────────
 
     def _ensure_watched_bots_table(self, conn):