@misterhuydo/sentinel 1.0.58 → 1.0.60

package/.cairn/.hint-lock

@@ -1 +1 @@
-2026-03-22T14:06:29.625Z
+2026-03-22T14:37:46.791Z

package/.cairn/minify-map.json

@@ -1 +1,8 @@
-{}
+{
+  "J:\\Projects\\Sentinel\\cli\\lib\\upgrade.js": {
+    "tempPath": "J:\\Projects\\Sentinel\\cli\\.cairn\\views\\fb78ac_upgrade.js",
+    "state": "compressed",
+    "minifiedAt": 1774129312316.9353,
+    "readCount": 1
+  }
+}

package/.cairn/session.json

@@ -1,6 +1,6 @@
 {
-  "message": "Auto-checkpoint at 2026-03-22T14:28:09.441Z",
-  "checkpoint_at": "2026-03-22T14:28:09.442Z",
+  "message": "Auto-checkpoint at 2026-03-22T14:43:35.624Z",
+  "checkpoint_at": "2026-03-22T14:43:35.625Z",
   "active_files": [],
   "notes": [],
   "mtime_snapshot": {}

package/.cairn/views/fb78ac_upgrade.js

@@ -0,0 +1,55 @@
+'use strict';
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+const { execSync, spawnSync } = require('child_process');
+const chalk = require('chalk');
+const ok   = msg => console.log(chalk.green('  ✔'), msg);
+const info = msg => console.log(chalk.cyan('  →'), msg);
+const warn = msg => console.log(chalk.yellow('  ⚠'), msg);
+module.exports = async function upgrade() {
+  const { version: current } = require('../package.json');
+  const defaultWorkspace = path.join(os.homedir(), 'sentinel');
+  const codeDir = path.join(defaultWorkspace, 'code');
+  if (!fs.existsSync(codeDir)) {
+    console.error(chalk.red('  ✖ Sentinel code directory not found at ' + codeDir));
+    console.error('    Run: sentinel init');
+    process.exit(1);
+  }
+  info(`Current version: ${current}`);
+  info('Installing latest @misterhuydo/sentinel...');
+  const install = spawnSync('npm', ['install', '-g', '@misterhuydo/sentinel@latest'], { stdio: 'inherit' });
+  if (install.status !== 0) {
+    console.error(chalk.red('  ✖ npm install failed'));
+    process.exit(1);
+  }
+  const npmRoot = execSync('npm root -g', { encoding: 'utf8' }).trim();
+  const pkgDir  = path.join(npmRoot, '@misterhuydo', 'sentinel');
+  const src     = path.join(pkgDir, 'python');
+  if (!fs.existsSync(src)) {
+    console.error(chalk.red('  ✖ Bundled Python source not found in installed package'));
+    process.exit(1);
+  }
+  info('Deploying Python source...');
+  fs.copySync(src, codeDir, { overwrite: true });
+  const scriptsDir = path.join(codeDir, 'scripts');
+  if (fs.existsSync(scriptsDir)) {
+    const shFiles = fs.readdirSync(scriptsDir)
+      .filter(f => f.endsWith('.sh'))
+      .map(f => path.join(scriptsDir, f));
+    if (shFiles.length) spawnSync('chmod', ['+x', ...shFiles], { stdio: 'inherit' });
+  }
+  ok('Python source updated');
+  const { version: latest } = require(path.join(pkgDir, 'package.json'));
+  ok(`Upgraded: ${current} → ${latest}`);
+  const startAll = path.join(defaultWorkspace, 'startAll.sh');
+  const stopAll  = path.join(defaultWorkspace, 'stopAll.sh');
+  if (fs.existsSync(stopAll) && fs.existsSync(startAll)) {
+    info('Restarting Sentinel...');
+    spawnSync('bash', [stopAll], { stdio: 'inherit' });
+    spawnSync('bash', [startAll], { stdio: 'inherit' });
+    ok('Sentinel restarted');
+  } else {
+    warn('No startAll.sh found — restart manually');
+  }
+};

package/package.json

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

package/python/sentinel/sentinel_boss.py

@@ -875,70 +875,36 @@ async def _run_tool(name: str, inputs: dict, cfg_loader, store, slack_client=Non
 
     if name == "upgrade_sentinel":
         import threading
-        import signal as _sig
-
-        code_dir    = Path(__file__).resolve().parent.parent  # sentinel repo root
-        project_dir = Path(".").resolve()
-        steps: list[dict] = []
-
-        # Step 1: git pull the sentinel agent code
-        pull = _git_pull(code_dir)
-        steps.append({"step": "git_pull", **pull})
-        already_latest = "already up to date" in pull.get("detail", "").lower()
-
-        if pull["status"] == "error":
-            return json.dumps({"status": "error", "steps": steps,
-                                "note": "git pull failed — check network / SSH key"})
-
-        # Step 2: pip install (update Python deps)
-        venv_pip = code_dir / ".venv" / "bin" / "pip"
-        pip_cmd  = str(venv_pip) if venv_pip.exists() else "pip3"
-        req_file = code_dir / "requirements.txt"
-        if req_file.exists():
-            try:
-                r = subprocess.run(
-                    [pip_cmd, "install", "-q", "-r", str(req_file)],
-                    capture_output=True, text=True, timeout=120,
-                )
-                steps.append({
-                    "step":   "pip_install",
-                    "status": "ok" if r.returncode == 0 else "warn",
-                    "detail": (r.stderr or "").strip()[:200],
-                })
-            except Exception as e:
-                steps.append({"step": "pip_install", "status": "warn", "detail": str(e)})
 
-        if already_latest:
+        # Sentinel is installed via npm — use `sentinel upgrade` which handles
+        # npm install + Python bundle copy + restart via stopAll/startAll.
+        # Run it in the background after a short delay so the Slack reply is
+        # sent before the process is replaced.
+        try:
+            r = subprocess.run(
+                ["sentinel", "--version"],
+                capture_output=True, text=True, timeout=10,
+            )
+            sentinel_bin_ok = r.returncode == 0
+        except Exception:
+            sentinel_bin_ok = False
+
+        if not sentinel_bin_ok:
             return json.dumps({
-                "status": "already_latest",
-                "steps":  steps,
-                "note":   "Sentinel is already up to date. No restart needed.",
+                "status": "error",
+                "note":   "`sentinel` CLI not found. Run: npm install -g @misterhuydo/sentinel",
             })
 
-        # Step 3: restart — schedule after response is sent
-        stop_sh  = project_dir / "stop.sh"
-        start_sh = project_dir / "start.sh"
-        if stop_sh.exists() and start_sh.exists():
-            def _restart_scripts():
-                import time; time.sleep(10)
-                subprocess.Popen(
-                    f"bash {stop_sh} && sleep 2 && bash {start_sh}",
-                    shell=True,
-                )
-            threading.Thread(target=_restart_scripts, daemon=True).start()
-            restart_method = "stop.sh + start.sh"
-        else:
-            # SIGTERM self — systemd (Restart=always) will bring it back up
-            # 10s delay gives Claude time to generate + post the reply before we die
-            threading.Timer(10.0, lambda: os.kill(os.getpid(), _sig.SIGTERM)).start()
-            restart_method = "SIGTERM → systemd restart"
+        def _do_upgrade():
+            import time
+            time.sleep(10)   # give Slack time to post the reply
+            subprocess.Popen(["sentinel", "upgrade"], close_fds=True)
 
-        steps.append({"step": "restart", "status": "scheduled", "method": restart_method})
-        logger.info("Boss: upgrade_sentinel complete, restarting via %s", restart_method)
+        threading.Thread(target=_do_upgrade, daemon=True).start()
+        logger.info("Boss: upgrade_sentinel scheduled via `sentinel upgrade`")
         return json.dumps({
             "status": "ok",
-            "steps":  steps,
-            "note":   "Upgrade complete. Sentinel is restarting — give it a few seconds then I'll be back.",
+            "note":   "Upgrade started — pulling latest version via npm and restarting. Give me ~30 seconds then I'll be back.",
         })
 
     return json.dumps({"error": f"unknown tool: {name}"})
@@ -955,6 +921,7 @@ async def _handle_with_cli(
     cfg_loader,
     store,
     slack_client=None,
+    user_name: str = "",
 ) -> 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)
@@ -989,6 +956,7 @@ async def _handle_with_cli(
 
     prompt = (
         _SYSTEM
+        + (f"\nYou are speaking with: {user_name}" if user_name else "")
         + f"\n\nCurrent time: {ts}"
         + f"\nSentinel status: {'⏸ PAUSED' if paused else '▶ RUNNING'}"
         + f"\nManaged repos: {', '.join(repos) if repos else '(none configured)'}"
@@ -1050,6 +1018,7 @@ async def handle_message(
     cfg_loader,
     store,
     slack_client=None,
+    user_name: str = "",
 ) -> tuple[str, bool]:
     """
     Process one user message through the Sentinel Boss (Claude with tool use).
@@ -1075,7 +1044,7 @@ async def handle_message(
 
     api_key = cfg_loader.sentinel.anthropic_api_key or os.environ.get("ANTHROPIC_API_KEY", "")
     if not api_key:
-        return await _handle_with_cli(message, history, cfg_loader, store, slack_client=slack_client)
+        return await _handle_with_cli(message, history, cfg_loader, store, slack_client=slack_client, user_name=user_name)
 
     client = anthropic.Anthropic(api_key=api_key)
 
@@ -1086,6 +1055,7 @@ async def handle_message(
     known_projects = [_read_project_name(d) for d in _find_project_dirs()]
     system    = (
         _SYSTEM
+        + (f"\nYou are speaking with: {user_name}" if user_name else "")
         + f"\n\nCurrent time: {ts}"
         + f"\nSentinel status: {'⏸ PAUSED' if paused else '▶ RUNNING'}"
         + f"\nManaged repos: {', '.join(repos) if repos else '(none configured)'}"

package/python/sentinel/slack_bot.py

@@ -330,6 +330,7 @@ async def _run_turn(session: _Session, message: str, client, cfg_loader, store)
         reply, is_done = await handle_message(
             message, session.history, cfg_loader, store,
             slack_client=client,
+            user_name=session.user_name,
         )
     except Exception as e:
         logger.exception("Sentinel Boss error: %s", e)