@misterhuydo/sentinel 1.0.5 → 1.0.6

package/lib/generate.js

@@ -73,7 +73,7 @@ if echo "$AUTH_OUT" | grep -Eqi "not logged in|/login"; then
   exit 1
 fi
 
-mkdir -p "$DIR/logs" "$DIR/workspace/fetched" "$DIR/workspace/patches"
+mkdir -p "$DIR/logs" "$DIR/workspace/fetched" "$DIR/workspace/patches" "$DIR/issues"
 cd "$DIR"
 PYTHONPATH="${codeDir}" "${pythonBin}" -m sentinel.main --config ./config \\
   >> "$DIR/logs/sentinel.log" 2>&1 &
@@ -109,17 +109,36 @@ rm -f "$PID_FILE"
 function generateWorkspaceScripts(workspace) {
   // startAll.sh
   fs.writeFileSync(path.join(workspace, 'startAll.sh'), `#!/usr/bin/env bash
-# Start all Sentinel project instances
+# Start all valid Sentinel project instances.
+# A valid project must have config/repo-configs/*.properties with a GitHub REPO_URL.
 WORKSPACE="$(cd "$(dirname "$0")" && pwd)"
 started=0
+skipped=0
 for project_dir in "$WORKSPACE"/*/; do
   name=$(basename "$project_dir")
   [[ "$name" == "code" ]] && continue
   [[ -f "$project_dir/start.sh" ]] || continue
+
+  # Must have at least one repo-config with a valid GitHub REPO_URL
+  valid_repo=false
+  for props in "$project_dir/config/repo-configs/"*.properties 2>/dev/null; do
+    [[ -f "$props" ]] || continue
+    if grep -qE "^REPO_URL[[:space:]]*=[[:space:]]*(git@github\.com:|https://github\.com/)" "$props"; then
+      valid_repo=true
+      break
+    fi
+  done
+
+  if [[ "$valid_repo" == "false" ]]; then
+    echo "[sentinel] Skipping $name — no valid REPO_URL found in config/repo-configs/"
+    skipped=$((skipped + 1))
+    continue
+  fi
+
   bash "$project_dir/start.sh"
   started=$((started + 1))
 done
-echo "[sentinel] $started project(s) started"
+echo "[sentinel] $started project(s) started, $skipped skipped"
 `, { mode: 0o755 });
 
   // stopAll.sh

package/package.json

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

package/python/sentinel/fix_engine.py

@@ -26,36 +26,39 @@ _DIFF_BLOCK = re.compile(r"```(?:diff|patch)?\n(.*?)```", re.DOTALL)
 _DIFF_HEADER = re.compile(r"^diff --git|^---\s+\S+|^\+\+\+\s+\S+", re.MULTILINE)
 
 
-def _build_prompt(event: ErrorEvent, repo: RepoConfig, log_file: Path) -> str:
-    return textwrap.dedent(f"""\
-        You are fixing a production bug in the repository at {repo.local_path}.
-        Repository: {repo.repo_name}
-
-        LOG FILE: {log_file}
-        Read this file first. It contains the last 48h of logs from {event.source} —
-        use it to understand the frequency, surrounding context, and any warnings
-        that preceded this error.
-
-        ERROR fingerprint to fix (from {event.source}):
-        {event.full_text()}
-
-        Task:
-        1. Read the log file above to understand what led up to this error.
-        2. Use your available tools to explore the codebase and identify the root cause.
-        3. Output ONLY a unified diff patch (git diff format) fixing the issue.
-        4. Do not explain. Output only the patch.
-        5. If you cannot determine a safe fix, output: SKIP: <reason>
-    """)
-
-
-def _extract_patch(output: str) -> str | None:
-    m = _DIFF_BLOCK.search(output)
-    if m:
-        return m.group(1).strip()
-    if _DIFF_HEADER.search(output):
-        return output.strip()
-    return None
-
+def _build_prompt(event, repo: RepoConfig, log_file) -> str:
+    if log_file and log_file.exists():
+        ctx = (
+            "LOG FILE: " + str(log_file) + "\n"
+            "Read this file first -- it contains the last 48h of logs from "
+            + event.source + ".\n"
+            "Use it to understand frequency, context, and preceding warnings."
+        )
+        step1 = "Read the log file above to understand what led up to this error."
+    else:
+        ctx = (
+            "SOURCE: " + event.source + "\n"
+            "No rolling log file available. The full issue description is below."
+        )
+        step1 = "Use the issue description above as your primary context."
+
+    lines_out = [
+        f"You are fixing a production bug in the repository at {repo.local_path}.",
+        f"Repository: {repo.repo_name}",
+        "",
+        ctx,
+        "",
+        f"ISSUE TO FIX (from {event.source}):",
+        event.full_text(),
+        "",
+        "Task:",
+        f"1. {step1}",
+        "2. Use your available tools to explore the codebase and identify the root cause.",
+        "3. Output ONLY a unified diff patch (git diff format) fixing the issue.",
+        "4. Do not explain. Output only the patch.",
+        "5. If you cannot determine a safe fix, output: SKIP: <reason>",
+    ]
+    return "\n".join(lines_out)
 
 def _validate_patch(patch: str) -> tuple[bool, str]:
     files_changed = len(re.findall(r"^diff --git", patch, re.MULTILINE))
@@ -83,7 +86,10 @@ def generate_fix(
         (status, patch_path)
         status: "patch" | "skip" | "error"
     """
+    # Issues have source like "issues/filename" — no rolling log file exists
     log_file = Path(cfg.workspace_dir) / "fetched" / f"{event.source}.log"
+    if not log_file.exists():
+        log_file = None
     prompt = _build_prompt(event, repo, log_file)
 
     logger.info("Invoking Claude Code for %s (fp=%s)", event.source, event.fingerprint)

package/python/sentinel/issue_watcher.py

@@ -0,0 +1,131 @@
+"""
+issue_watcher.py — Scan the issues/ directory for manually-submitted bug reports.
+
+Admins drop plain-text or markdown files into <project>/issues/.
+Each file is treated as a fix request. Processed files are archived to issues/.done/.
+
+File format (TARGET_REPO header is optional):
+
+    TARGET_REPO: my-repo-name
+
+    Short summary of the problem (becomes the email subject line)
+
+    Any details: customer feedback, stack traces, screenshots text, etc.
+    If TARGET_REPO is omitted and only one repo is configured, it is used automatically.
+"""
+
+import hashlib
+import logging
+import time
+from dataclasses import dataclass, field
+from datetime import datetime, timezone
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+_TARGET_REPO_PREFIX = "TARGET_REPO:"
+
+
+@dataclass
+class IssueEvent:
+    """
+    A fix request sourced from the issues/ directory.
+    Implements the same interface as ErrorEvent so it can flow through
+    the same fix pipeline (_handle_error / generate_fix / git_manager).
+    """
+    source: str        # "issues/<filename>" — shown in emails and logs
+    issue_file: Path   # full path, used for archiving after processing
+    message: str       # first non-blank body line — used as subject summary
+    body: str          # full file content (the issue description)
+    target_repo: str   # explicit TARGET_REPO value, or "" for auto-select
+    fingerprint: str = ""
+    severity: str = "ERROR"
+    timestamp: str = ""
+
+    # Compatibility fields matching ErrorEvent interface
+    level: str = "ERROR"
+    thread: str = ""
+    logger_name: str = ""
+    stack_trace: list[str] = field(default_factory=list)
+    log_file: str = ""
+
+    def __post_init__(self):
+        if not self.fingerprint:
+            raw = f"issue:{self.source}:{self.message[:200]}"
+            self.fingerprint = hashlib.sha1(raw.encode()).hexdigest()[:16]
+        if not self.timestamp:
+            self.timestamp = datetime.now(timezone.utc).isoformat()
+        if not self.stack_trace:
+            self.stack_trace = self.body.splitlines()
+
+    @property
+    def is_infra_issue(self) -> bool:
+        return False
+
+    def short_summary(self) -> str:
+        return self.message[:120]
+
+    def full_text(self) -> str:
+        return self.body
+
+
+def scan_issues(project_dir: Path) -> list[IssueEvent]:
+    """
+    Return all pending issue files from <project_dir>/issues/.
+    Files starting with '.' and files inside .done/ are skipped.
+    """
+    issues_dir = project_dir / "issues"
+    if not issues_dir.exists():
+        return []
+
+    events = []
+    for f in sorted(issues_dir.iterdir()):
+        if not f.is_file() or f.name.startswith("."):
+            continue
+
+        try:
+            content = f.read_text(encoding="utf-8", errors="replace").strip()
+        except OSError as e:
+            logger.error("Cannot read issue file %s: %s", f, e)
+            continue
+
+        if not content:
+            continue
+
+        lines = content.splitlines()
+        target_repo = ""
+        body_start = 0
+
+        # Parse optional TARGET_REPO: header (must be the first non-blank line)
+        for i, line in enumerate(lines):
+            stripped = line.strip()
+            if stripped.upper().startswith(_TARGET_REPO_PREFIX):
+                target_repo = stripped[len(_TARGET_REPO_PREFIX):].strip()
+                body_start = i + 1
+            elif stripped:
+                break
+
+        body = "\n".join(lines[body_start:]).strip() or content
+        message = next((l.strip() for l in lines[body_start:] if l.strip()), f.name)
+
+        events.append(IssueEvent(
+            source=f"issues/{f.name}",
+            issue_file=f,
+            message=message,
+            body=body,
+            target_repo=target_repo,
+        ))
+        logger.info("Found issue: %s (target_repo=%r)", f.name, target_repo or "auto")
+
+    return events
+
+
+def mark_done(issue_file: Path) -> None:
+    """Archive a processed issue to issues/.done/ regardless of outcome."""
+    done_dir = issue_file.parent / ".done"
+    done_dir.mkdir(exist_ok=True)
+    dest = done_dir / issue_file.name
+    if dest.exists():
+        dest = done_dir / f"{issue_file.stem}-{int(time.time())}{issue_file.suffix}"
+    issue_file.rename(dest)
+    logger.info("Issue archived: %s -> .done/%s", issue_file.name, dest.name)

package/python/sentinel/main.py

@@ -22,8 +22,9 @@ from .git_manager import apply_and_commit, publish
 from .cicd_trigger import trigger as cicd_trigger
 from .log_fetcher import fetch_all
 from .log_parser import parse_all, ErrorEvent
+from .issue_watcher import scan_issues, mark_done, IssueEvent
 from .repo_router import route
-from .reporter import build_and_send, send_fix_notification
+from .reporter import build_and_send, send_fix_notification, send_failure_notification
 from .state_store import StateStore
 
 logging.basicConfig(
@@ -83,12 +84,27 @@ async def _handle_error(event: ErrorEvent, cfg_loader: ConfigLoader, store: Stat
     status, patch_path = generate_fix(event, repo, sentinel, patches_dir)
 
     if status != "patch" or patch_path is None:
-        store.record_fix(event.fingerprint, "skipped" if status == "skip" else "failed", repo_name=repo.repo_name)
+        outcome = "skipped" if status == "skip" else "failed"
+        store.record_fix(event.fingerprint, outcome, repo_name=repo.repo_name)
+        send_failure_notification(sentinel, {
+            "source":    event.source,
+            "message":   event.message,
+            "repo_name": repo.repo_name,
+            "reason":    f"Claude Code returned {status.upper()}",
+            "body":      event.full_text()[:500],
+        })
         return
 
     commit_status, commit_hash = apply_and_commit(event, patch_path, repo, sentinel)
     if commit_status != "committed":
         store.record_fix(event.fingerprint, "failed", repo_name=repo.repo_name)
+        send_failure_notification(sentinel, {
+            "source":    event.source,
+            "message":   event.message,
+            "repo_name": repo.repo_name,
+            "reason":    "patch generated but commit/tests failed",
+            "body":      event.full_text()[:500],
+        })
         return
 
     branch, pr_url = publish(event, repo, sentinel, commit_hash)
@@ -123,28 +139,129 @@ async def _handle_error(event: ErrorEvent, cfg_loader: ConfigLoader, store: Stat
 
 # ── Poll cycle ────────────────────────────────────────────────────────────────
 
-async def poll_cycle(cfg_loader: ConfigLoader, store: StateStore):
-    global _report_requested
 
-    sources = list(cfg_loader.log_sources.values())
-    if not sources:
-        logger.warning("No log-configs found")
+# ── Issue pipeline ────────────────────────────────────────────────────────────
+
+async def _handle_issue(event: IssueEvent, cfg_loader: ConfigLoader, store: StateStore):
+    """Process a single issue file from the issues/ directory."""
+    sentinel = cfg_loader.sentinel
+
+    if Path("SENTINEL_PAUSE").exists():
+        logger.info("SENTINEL_PAUSE present -- fix activity halted")
         return
 
-    logger.info("Fetching logs from %d source(s)...", len(sources))
-    fetched = await fetch_all(sources, cfg_loader.sentinel)
+    if store.fix_attempted_recently(event.fingerprint, hours=24):
+        logger.debug("Issue already processed recently: %s", event.source)
+        mark_done(event.issue_file)
+        return
+
+    # Route: explicit TARGET_REPO in file > single-repo shortcut > warn and leave
+    if event.target_repo:
+        repo = cfg_loader.repos.get(event.target_repo)
+        if not repo:
+            logger.warning("TARGET_REPO %r not found in config -- leaving %s for admin",
+                           event.target_repo, event.source)
+            return
+    elif len(cfg_loader.repos) == 1:
+        repo = next(iter(cfg_loader.repos.values()))
+    else:
+        logger.warning(
+            "Cannot auto-route %s -- add 'TARGET_REPO: <repo>' as first line in the file",
+            event.source,
+        )
+        return  # Leave the file so admin can add the header
+
+    patches_dir = Path(sentinel.workspace_dir) / "patches"
+    status, patch_path = generate_fix(event, repo, sentinel, patches_dir)
+
+    if status != "patch" or patch_path is None:
+        store.record_fix(event.fingerprint, "skipped" if status == "skip" else "failed",
+                         repo_name=repo.repo_name)
+        send_failure_notification(sentinel, {
+            "source":    event.source,
+            "message":   event.message,
+            "repo_name": repo.repo_name,
+            "reason":    f"Claude Code returned {status.upper()}",
+            "body":      event.body[:500],
+        })
+        mark_done(event.issue_file)
+        return
 
-    events = parse_all(fetched, cfg_loader.log_sources)
-    logger.info("Parsed %d error/warn events", len(events))
+    commit_status, commit_hash = apply_and_commit(event, patch_path, repo, sentinel)
+    if commit_status != "committed":
+        store.record_fix(event.fingerprint, "failed", repo_name=repo.repo_name)
+        send_failure_notification(sentinel, {
+            "source":    event.source,
+            "message":   event.message,
+            "repo_name": repo.repo_name,
+            "reason":    "patch generated but commit/tests failed",
+            "body":      event.body[:500],
+        })
+        mark_done(event.issue_file)
+        return
 
-    new_events = []
-    for event in events:
-        store.record_error(event.fingerprint, event.source, event.message)
-        if not store.fix_attempted_recently(event.fingerprint):
-            new_events.append(event)
+    branch, pr_url = publish(event, repo, sentinel, commit_hash)
+    store.record_fix(
+        event.fingerprint,
+        "applied" if repo.auto_publish else "pending",
+        patch_path=str(patch_path),
+        commit_hash=commit_hash,
+        branch=branch,
+        pr_url=pr_url,
+        repo_name=repo.repo_name,
+    )
+    send_fix_notification(sentinel, {
+        "source":       event.source,
+        "severity":     "ERROR",
+        "fingerprint":  event.fingerprint,
+        "first_seen":   event.timestamp,
+        "message":      event.message,
+        "stack_trace":  event.body,
+        "repo_name":    repo.repo_name,
+        "commit_hash":  commit_hash,
+        "branch":       branch,
+        "pr_url":       pr_url,
+        "auto_publish": repo.auto_publish,
+        "files_changed": [],
+    })
+    mark_done(event.issue_file)
+
+    if repo.auto_publish:
+        cicd_trigger(repo, store, event.fingerprint)
+
+
+async def poll_cycle(cfg_loader: ConfigLoader, store: StateStore):
+    global _report_requested
+
+    # ── Log sources (optional) ────────────────────────────────────────────────
+    sources = list(cfg_loader.log_sources.values())
+    if sources:
+        logger.info("Fetching logs from %d source(s)...", len(sources))
+        fetched = await fetch_all(sources, cfg_loader.sentinel)
+        events = parse_all(fetched, cfg_loader.log_sources)
+        logger.info("Parsed %d error/warn events", len(events))
+
+        new_events = []
+        for event in events:
+            store.record_error(event.fingerprint, event.source, event.message)
+            if not store.fix_attempted_recently(event.fingerprint):
+                new_events.append(event)
+
+        if new_events:
+            logger.info("%d new log event(s) to process", len(new_events))
+            await asyncio.gather(
+                *[_handle_error(e, cfg_loader, store) for e in new_events],
+                return_exceptions=True,
+            )
 
-    logger.info("%d new event(s) to process", len(new_events))
-    await asyncio.gather(*[_handle_error(e, cfg_loader, store) for e in new_events], return_exceptions=True)
+    # ── Issues directory (always checked) ────────────────────────────────────
+    issues = scan_issues(Path("."))
+    if issues:
+        logger.info("%d issue file(s) found in issues/", len(issues))
+        await asyncio.gather(
+            *[_handle_issue(e, cfg_loader, store) for e in issues],
+            return_exceptions=True,
+        )
 
     if cfg_loader.sentinel.send_health and (_report_requested or _report_due(cfg_loader, store)):
         _report_requested = False
@@ -216,6 +333,7 @@ def main():
     Path("logs").mkdir(exist_ok=True)
     Path("workspace/fetched").mkdir(parents=True, exist_ok=True)
     Path("workspace/patches").mkdir(parents=True, exist_ok=True)
+    Path("issues").mkdir(exist_ok=True)
 
     parser = argparse.ArgumentParser(description="Sentinel — Autonomous DevOps Agent")
     parser.add_argument("--init", action="store_true", help="First-time setup")

package/python/sentinel/reporter.py

@@ -136,3 +136,53 @@ def _age(ts_str: str) -> str:
         return f"{int(delta.total_seconds() // 60)}m" if hours < 1 else f"{hours}h"
     except Exception:
         return "?"
+
+def send_failure_notification(cfg: SentinelConfig, details: dict):
+    """
+    Notify admins when Claude Code cannot fix a problem (from logs or issues/).
+
+    details dict keys: source, message, repo_name, reason, body
+    """
+    if not cfg.mails:
+        return
+
+    source    = details.get('source', 'unknown')
+    repo_name = details.get('repo_name', 'unknown')
+    reason    = details.get('reason', 'unknown')
+    message   = details.get('message', '')
+    body      = details.get('body', '')[:1000]
+    ts        = datetime.now(timezone.utc).strftime('%Y-%m-%d %H:%M UTC')
+
+    subject = f'[Sentinel] UNRESOLVED ({source}): {message[:80]}'
+
+    ctx_html = f'<h3>Context</h3><pre>{body}</pre>' if body else ''
+    html = (
+        '<!DOCTYPE html><html><head><meta charset="utf-8">'
+        '<style>'
+        'body{font-family:Arial,sans-serif;font-size:14px;color:#222}'
+        'h2{color:#c62828}'
+        'h3{color:#444;border-bottom:1px solid #ddd;padding-bottom:4px}'
+        'table{border-collapse:collapse;width:100%;margin-bottom:16px}'
+        'th{background:#f1f3f4;text-align:left;padding:6px 10px}'
+        'td{padding:5px 10px;border-bottom:1px solid #eee;vertical-align:top}'
+        '.label{font-weight:bold;width:160px}'
+        '.mono{font-family:monospace;font-size:12px}'
+        'pre{background:#f8f8f8;border:1px solid #ddd;padding:10px;font-size:12px;white-space:pre-wrap}'
+        '</style></head><body>'
+        '<h2>&#x26A0; Sentinel could not fix this issue</h2>'
+        f'<p><strong>{repo_name}</strong> &middot; {ts}</p>'
+        '<h3>Details</h3>'
+        '<table>'
+        f'<tr><td class="label">Source</td><td class="mono">{source}</td></tr>'
+        f'<tr><td class="label">Repository</td><td class="mono">{repo_name}</td></tr>'
+        f'<tr><td class="label">Message</td><td class="mono">{message}</td></tr>'
+        f'<tr><td class="label">Reason</td><td>{reason}</td></tr>'
+        '</table>'
+        + ctx_html +
+        '<hr><small>Sentinel &mdash; Autonomous DevOps Agent</small>'
+        '</body></html>'
+    )
+
+    _send_email(cfg, subject, html)
+    logger.info('Failure notification sent for %s', source)
+