@misterhuydo/sentinel 1.4.49 → 1.4.51

package/.cairn/session.json

@@ -1,6 +1,6 @@
 {
-  "message": "Auto-checkpoint at 2026-03-25T11:16:59.180Z",
-  "checkpoint_at": "2026-03-25T11:16:59.181Z",
+  "message": "Auto-checkpoint at 2026-03-25T11:34:55.696Z",
+  "checkpoint_at": "2026-03-25T11:34:55.697Z",
   "active_files": [],
   "notes": [],
   "mtime_snapshot": {}

package/package.json

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

package/python/sentinel/git_manager.py

@@ -21,6 +21,13 @@ logger = logging.getLogger(__name__)
 
 GIT_TIMEOUT = 60
 
+
+class MissingToolError(Exception):
+    """Raised when a required build tool (e.g. mvn, gradle) is not installed."""
+    def __init__(self, tool: str):
+        super().__init__(f"Build tool '{tool}' not found on this server")
+        self.tool = tool
+
 # Files that must never be modified by Sentinel
 _PROTECTED_PATHS = {".github/", "Jenkinsfile", "pom.xml"}
 
@@ -127,8 +134,7 @@ def _run_tests(repo: RepoConfig, local_path: str) -> bool:
     try:
         r = subprocess.run(cmd, cwd=local_path, capture_output=True, text=True, timeout=300)
     except FileNotFoundError:
-        logger.warning("Test runner '%s' not found on this server — skipping tests for %s", cmd[0], repo.repo_name)
-        return True
+        raise MissingToolError(cmd[0])
     if r.returncode != 0:
         logger.error("Tests failed:\n%s", r.stdout[-2000:] + r.stderr[-1000:])
         return False

package/python/sentinel/main.py

@@ -22,14 +22,14 @@ from pathlib import Path
 from .cairn_client import ensure_installed as cairn_installed, index_repo
 from .config_loader import ConfigLoader, SentinelConfig
 from .fix_engine import generate_fix
-from .git_manager import apply_and_commit, publish, _git_env
+from .git_manager import apply_and_commit, publish, _git_env, MissingToolError
 from .cicd_trigger import trigger as cicd_trigger
 from .log_fetcher import fetch_all
 from .log_parser import parse_all, scan_all_for_markers, ErrorEvent
 from .issue_watcher import scan_issues, mark_done, IssueEvent
 from .repo_router import route
 from .reporter import build_and_send, send_fix_notification, send_failure_notification, send_confirmed_notification, send_regression_notification, send_startup_notification, send_upgrade_notification
-from .notify import notify_fix_blocked, notify_fix_applied
+from .notify import notify_fix_blocked, notify_fix_applied, notify_missing_tool
 from .health_checker import evaluate_repos
 from .state_store import StateStore
 
@@ -106,7 +106,13 @@ async def _handle_error(event: ErrorEvent, cfg_loader: ConfigLoader, store: Stat
             })
         return
 
-    commit_status, commit_hash = apply_and_commit(event, patch_path, repo, sentinel)
+    try:
+        commit_status, commit_hash = apply_and_commit(event, patch_path, repo, sentinel)
+    except MissingToolError as e:
+        logger.warning("Missing tool for %s: %s — notifying admin", event.source, e)
+        notify_missing_tool(sentinel, e.tool, repo.repo_name, event.source, "")
+        store.record_fix(event.fingerprint, "failed", repo_name=repo.repo_name)
+        return
     if commit_status != "committed":
         store.record_fix(event.fingerprint, "failed", repo_name=repo.repo_name)
         send_failure_notification(sentinel, {
@@ -244,6 +250,14 @@ async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: Stat
         if repo.auto_publish:
             cicd_trigger(repo, store, event.fingerprint)
 
+    except MissingToolError as e:
+        logger.warning("Missing tool for %s: %s — notifying admin", event.source, e)
+        submitter_uid = getattr(event, "submitter_user_id", "")
+        notify_missing_tool(sentinel, e.tool, repo.repo_name, event.source, submitter_uid)
+        # Archive the issue — admin can re-raise it after installing the tool
+        store.record_fix(event.fingerprint, "failed", repo_name=repo.repo_name)
+        mark_done(event.issue_file)
+
     except Exception:
         logger.exception("Unexpected error processing issue %s — archiving to prevent retry loop", event.source)
         store.record_fix(event.fingerprint, "failed", repo_name=repo.repo_name)

package/python/sentinel/notify.py

@@ -230,6 +230,34 @@ def notify_fix_blocked(
         logger.warning("notify_fix_blocked: email notification failed: %s", exc)
 
 
+def notify_missing_tool(
+    cfg,
+    tool: str,
+    repo_name: str,
+    source: str,
+    submitter_user_id: str = "",
+) -> None:
+    """
+    Notify admins that a build tool is missing on this server.
+    Prompts them to ask Boss to install it.
+    """
+    repo_line = f" for *{repo_name}*" if repo_name else ""
+    slack_text = (
+        f":wrench: *Build tool missing{repo_line}*\n"
+        f"*Source:* {source}\n"
+        f"The fix was generated but tests couldn't run because `{tool}` is not installed on this server.\n\n"
+        f"Ask me to install it:\n"
+        f"> @Sentinel install {tool}\n\n"
+        f"Once installed, re-raise the issue to apply the fix."
+    )
+    if submitter_user_id:
+        if getattr(cfg, "slack_dm_submitter", True):
+            slack_dm(cfg.slack_bot_token, submitter_user_id, slack_text)
+        slack_alert(cfg.slack_bot_token, cfg.slack_channel, f"<@{submitter_user_id}> {slack_text}")
+    else:
+        slack_alert(cfg.slack_bot_token, cfg.slack_channel, f"<!channel> {slack_text}")
+
+
 def notify_fix_applied(
     cfg,
     source: str,

package/python/sentinel/sentinel_boss.py

@@ -395,6 +395,30 @@ _TOOLS = [
             "required": ["fingerprint"],
         },
     },
+    {
+        "name": "retry_issue",
+        "description": (
+            "Re-queue a previously failed or blocked issue from the archive without requiring the "
+            "user to re-type the context. Scans issues/.done/ for the most recent matching file "
+            "and re-submits it to Sentinel. "
+            "Use when the user says things like: 'retry the last issue', 're-raise the umlaut fix', "
+            "'try that again', 'retry Whydah-TypeLib', 'run the last failed fix again'."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "project": {
+                    "type": "string",
+                    "description": "Project short name (e.g. '1881'). Required.",
+                },
+                "keyword": {
+                    "type": "string",
+                    "description": "Optional keyword to match against archived issue content (e.g. 'umlaut', 'Whydah-TypeLib')",
+                },
+            },
+            "required": ["project"],
+        },
+    },
     {
         "name": "list_pending_prs",
         "description": "List all open Sentinel PRs awaiting admin review.",
@@ -931,6 +955,25 @@ _TOOLS = [
             "required": ["repo_name"],
         },
     },
+    {
+        "name": "install_tool",
+        "description": (
+            "ADMIN ONLY. Install a missing build tool (e.g. maven, gradle, node) on this server "
+            "using Claude Code with shell execution rights. "
+            "Use after Sentinel reports a missing tool error. "
+            "e.g. 'install maven', 'install gradle', '@Sentinel install mvn'"
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "tool_name": {
+                    "type": "string",
+                    "description": "The tool to install, e.g. 'maven', 'gradle', 'node'",
+                },
+            },
+            "required": ["tool_name"],
+        },
+    },
     {
         "name": "set_maintenance",
         "description": (
@@ -1228,6 +1271,65 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
             "note":    f"Delivered to '{project_label}'. Sentinel will process it on the next poll cycle.",
         })
 
+    if name == "retry_issue":
+        project_arg = inputs.get("project", "").strip()
+        keyword     = inputs.get("keyword", "").strip().lower()
+
+        project_dirs = _find_project_dirs(project_arg) if project_arg else _find_project_dirs()
+        if not project_dirs:
+            return json.dumps({"error": f"No project found matching '{project_arg}'"})
+        if len(project_dirs) > 1 and project_arg:
+            return json.dumps({"error": f"Ambiguous project '{project_arg}' — matches: {[_read_project_name(d) for d in project_dirs]}"})
+
+        project_dir  = project_dirs[0]
+        done_dir     = project_dir / "issues" / ".done"
+        if not done_dir.exists():
+            return json.dumps({"error": "No archived issues found — issues/.done/ does not exist"})
+
+        # Find all archived issue files, newest first
+        candidates = sorted(
+            [f for f in done_dir.iterdir() if f.is_file() and not f.name.startswith(".")],
+            key=lambda f: f.stat().st_mtime,
+            reverse=True,
+        )
+        if not candidates:
+            return json.dumps({"error": "No archived issues found in issues/.done/"})
+
+        # Filter by keyword if provided
+        if keyword:
+            matched = []
+            for f in candidates:
+                try:
+                    content = f.read_text(encoding="utf-8", errors="replace")
+                    if keyword in content.lower():
+                        matched.append(f)
+                except OSError:
+                    pass
+            if not matched:
+                return json.dumps({"error": f"No archived issues match keyword '{keyword}'"})
+            candidates = matched
+
+        source_file = candidates[0]
+        content     = source_file.read_text(encoding="utf-8", errors="replace")
+
+        # Re-submit as a fresh issue file (new name = new fingerprint = no cooldown block)
+        issues_dir = project_dir / "issues"
+        issues_dir.mkdir(exist_ok=True)
+        fname = f"retry-{source_file.stem[-8:]}-{uuid.uuid4().hex[:6]}.txt"
+        (issues_dir / fname).write_text(content, encoding="utf-8")
+        (project_dir / "SENTINEL_POLL_NOW").touch()
+
+        project_label = _read_project_name(project_dir.resolve())
+        logger.info("Boss retry_issue: re-queued '%s' as '%s' for %s", source_file.name, fname, project_label)
+        return json.dumps({
+            "status":       "re-queued",
+            "project":      project_label,
+            "original_file": source_file.name,
+            "new_file":     fname,
+            "note":         f"Re-submitted '{source_file.name}' to '{project_label}'. Poll triggered.",
+        })
+
+
     if name == "get_fix_details":
         fp  = inputs["fingerprint"]
         fix = store.get_confirmed_fix(fp) or store.get_marker_seen_fix(fp)
@@ -2193,7 +2295,7 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
         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", "merge_pr"}
+    _ADMIN_TOOLS = {"list_all_users", "clear_user_history", "reset_fingerprint", "list_all_errors", "export_db", "merge_pr", "install_tool"}
     if name in _ADMIN_TOOLS:
         if not is_admin:
             return json.dumps({"error": "Admin access required. You are not in SLACK_ADMIN_USERS."})
@@ -2380,6 +2482,43 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
             return json.dumps({"status": "error", "pr": pr_url,
                                "error": f"GitHub API returned {merge_resp.status_code}: {merge_resp.text[:300]}"})
 
+    if name == "install_tool":
+        import subprocess as _sp
+        tool_name = inputs.get("tool_name", "").strip()
+        if not tool_name:
+            return json.dumps({"error": "tool_name is required"})
+
+        bin_path = cfg_loader.sentinel.claude_code_bin
+        api_key  = cfg_loader.sentinel.anthropic_api_key
+        env      = {**_os.environ}
+        if api_key:
+            env["ANTHROPIC_API_KEY"] = api_key
+
+        prompt = (
+            f"Install '{tool_name}' on this server so it can be used as a build/test tool. "
+            f"Detect the OS and package manager (yum/dnf/apt), then run the appropriate install command. "
+            f"After installing, verify the installation by running '{tool_name} --version' or the equivalent. "
+            f"Report the installed version. Do not explain — just install and report."
+        )
+        logger.info("Boss install_tool: installing '%s' via Claude Code", tool_name)
+        try:
+            result = _sp.run(
+                [bin_path, "--dangerously-skip-permissions", "--bare", "--print", prompt],
+                capture_output=True, text=True, timeout=300, env=env,
+            )
+            output = ((result.stdout or "") + (result.stderr or "")).strip()
+            success = result.returncode == 0
+            logger.info("Boss install_tool: '%s' install %s:\n%s", tool_name, "OK" if success else "FAILED", output[-500:])
+            return json.dumps({
+                "status": "installed" if success else "failed",
+                "tool": tool_name,
+                "output": output[-1000:],
+            })
+        except FileNotFoundError:
+            return json.dumps({"error": f"Claude Code binary not found at '{bin_path}'"})
+        except _sp.TimeoutExpired:
+            return json.dumps({"error": f"Install timed out for '{tool_name}'"})
+
     return json.dumps({"error": f"unknown tool: {name}"})