@yemi33/minions 0.1.1120 → 0.1.1122

package/CHANGELOG.md

@@ -1,5 +1,51 @@
 # Changelog
 
+## 0.1.1122 (2026-04-18)
+
+### Features
+- validate project name and path on POST /api/projects/add (SEC-04, SEC-05) (#1298)
+- seed realActivityMap at spawn time, stamp pid in live-output (#1200)
+
+### Fixes
+- scheduler double-fire within same cron minute (#1277)
+-  gate auto-fix dispatch on throttle state to prevent stale-data spurious fixes
+- preserve buildErrorLog through transient build states (#1232) (#1274)
+- annotate fast-exit empty-output failures with diagnostic hint (#1276)
+- invalidate PRD cache on pr-links.json change + guard aggregate PRs (#1220) (#1272)
+- pass --add-dir for minions + ~/.claude to agents (#1271)
+- preserve VERDICT marker by tail-slicing agent output (#1234) (#1270)
+- PRD info cache staleness and aggregate PR bleed-through (#1222)
+-  avoid no-op work item writes
+-  resilient claude binary resolution + surface spawn errors
+-  resolve native claude.exe from npm wrapper on Windows
+- cap temp-agent creation at maxConcurrent per tick (#1219)
+-  reassign pending items from unspawned temp agents to idle named agents (#1204) (#1212)
+- guard undefined agent in pending dispatch loop (closes #1206) (#1210)
+-  improve fallback meeting conclusion
+-  remove command center chevron
+- stamp live-output.log stub before spawn (#1198)
+-  harden settings save and migrate pr poll config
+
+### Other
+- docs(skill): add substitute-scheduler-template-vars (#1278)
+- Clarify PR poll labels
+- Prevent modal opens on text selection
+- refactor: clarify settings page section structure and PR polling dependencies
+- refactor: extract _probeClaudePackage helper, use shared.log for spawn errors
+- Make work item descriptions scrollable
+- Use PAT for publish merges
+- test(queries): add unit tests for invalidateDispatchCache/getInbox/getAgentCharter (#1214)
+- test(shared): add unit tests for truncateTextBytes/tailTextBytes/execSilent/trackReviewMetric/parseCanonicalPrId (#1215)
+- Fix publish workflow merge
+- chore: raise default meeting round timeout
+- Harden prompt context handling
+- Harden loop watch conversion
+- Add watches sidebar activity badge
+- test(cli): add unit tests for handleCommand, start, stop, kill, spawn (#1191)
+- chore: untrack pipeline files — local config only
+- restore: recover daily-arch-improvement and weekly-dead-code-cleanup pipelines
+- Harden CC stream resilience
+
 ## 0.1.1120 (2026-04-18)
 
 ### Features

package/dashboard.js

@@ -3658,12 +3658,58 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     } catch (e) { return jsonReply(res, 500, { error: e.message }); }
   }
 
+  // ── Non-repo confirmation tokens (SEC-05) ───────────────────────────────
+  // Single-use, short-TTL tokens that the client must obtain from
+  // POST /api/projects/confirm-token before a non-repo path can be added.
+  // This forces an explicit round-trip — a single forged POST to /add
+  // can no longer silently register a non-repo path as a project.
+  const _projectConfirmTokens = new Map(); // token → expiresAt (ms epoch)
+  const PROJECT_CONFIRM_TOKEN_TTL_MS = 5 * 60 * 1000; // 5 minutes
+
+  function _sweepProjectConfirmTokens() {
+    const now = Date.now();
+    for (const [t, exp] of _projectConfirmTokens) {
+      if (exp <= now) _projectConfirmTokens.delete(t);
+    }
+  }
+
+  function _consumeProjectConfirmToken(token) {
+    if (typeof token !== 'string' || !token) return false;
+    _sweepProjectConfirmTokens();
+    const exp = _projectConfirmTokens.get(token);
+    if (!exp) return false;
+    _projectConfirmTokens.delete(token); // single-use
+    return exp > Date.now();
+  }
+
+  async function handleProjectsConfirmToken(req, res) {
+    _sweepProjectConfirmTokens();
+    const token = require('crypto').randomUUID();
+    _projectConfirmTokens.set(token, Date.now() + PROJECT_CONFIRM_TOKEN_TTL_MS);
+    return jsonReply(res, 200, { confirmToken: token, ttlMs: PROJECT_CONFIRM_TOKEN_TTL_MS });
+  }
+
   async function handleProjectsAdd(req, res) {
     try {
       const body = await readBody(req);
       if (!body.path) return jsonReply(res, 400, { error: 'path required' });
-      const target = path.resolve(body.path);
-      if (!fs.existsSync(target)) return jsonReply(res, 400, { error: 'Directory not found: ' + target });
+
+      // SEC-05: validate path (must be a git repo, unless caller supplies
+      // allowNonRepo + a valid single-use confirmation token). Runs BEFORE any
+      // mutation of config.json so a rejected path leaves no side effects.
+      let target;
+      try {
+        target = shared.validateProjectPath(body.path, {
+          allowNonRepo: body.allowNonRepo === true,
+          confirmToken: body.confirmToken,
+          isValidToken: _consumeProjectConfirmToken,
+        });
+      } catch (e) {
+        return jsonReply(res, e.statusCode || 400, {
+          error: e.message,
+          ...(e.needsConfirmation ? { needsConfirmation: true } : {}),
+        });
+      }
 
       const configPath = path.join(MINIONS_DIR, 'config.json');
       const config = safeJsonObj(configPath);
@@ -3711,7 +3757,20 @@ What would you like to discuss or change? When you're happy, say "approve" and I
         }
       } catch { /* optional */ }
 
-      const name = body.name || detected.name;
+      const rawName = body.name || detected.name;
+
+      // SEC-04: validate project name — rejects path traversal, shell
+      // metacharacters, whitespace, overly long names. Runs BEFORE any
+      // mutation of config.json. Auto-detected names (from package.json /
+      // directory basename) also go through this check so a maliciously
+      // named repo on disk can't inject metacharacters either.
+      let name;
+      try {
+        name = shared.validateProjectName(rawName);
+      } catch (e) {
+        return jsonReply(res, e.statusCode || 400, { error: e.message });
+      }
+
       const prUrlBase = detected.repoHost === 'github'
         ? (detected.org && detected.repoName ? `https://github.com/${detected.org}/${detected.repoName}/pull/` : '')
         : (detected.org && detected.project && detected.repoName
@@ -5007,7 +5066,8 @@ What would you like to discuss or change? When you're happy, say "approve" and I
     // Projects
     { method: 'POST', path: '/api/projects/browse', desc: 'Open folder picker dialog, return selected path', handler: handleProjectsBrowse },
     { method: 'POST', path: '/api/projects/scan', desc: 'Scan a directory for git repos', params: 'path?, depth?', handler: handleProjectsScan },
-    { method: 'POST', path: '/api/projects/add', desc: 'Auto-discover and add a project to config', params: 'path, name?', handler: handleProjectsAdd },
+    { method: 'POST', path: '/api/projects/confirm-token', desc: 'Mint a single-use UUID token required to add a non-repo path (SEC-05)', handler: handleProjectsConfirmToken },
+    { method: 'POST', path: '/api/projects/add', desc: 'Auto-discover and add a project to config (name validated SEC-04; path validated SEC-05)', params: 'path, name?, allowNonRepo?, confirmToken?', handler: handleProjectsAdd },
 
     // Bug Filing
     { method: 'POST', path: '/api/issues/create', desc: 'File a bug on the Minions repo (yemi33/minions)', params: 'title, description?, labels?', handler: handleFileBug },

package/engine/scheduler.js

@@ -78,7 +78,21 @@ function parseCronExpr(expr) {
 
 /**
  * Check if a schedule should fire now, given its last run time.
- * Prevents double-firing within the same minute window.
+ * Prevents double-firing within the same cron minute.
+ *
+ * Uses a calendar-minute comparison (year/month/date/hour/minute) instead of a
+ * fixed elapsed-time threshold. A cron minute window spans a full 60 seconds
+ * (e.g. 05:00:00 → 05:00:59), so an elapsed-time guard must also be ≥ 60s —
+ * but then two fires at 04:59:58 and 05:00:00 (different cron windows) would
+ * collapse incorrectly. Calendar-minute comparison handles both cases cleanly:
+ * any two fires in the same wall-clock minute are the same cron window, and
+ * any two fires in different wall-clock minutes are distinct cron windows.
+ *
+ * Regression note (W-mo3zu273f8tm): the old 55s threshold let two fires 58s
+ * apart inside the same cron minute (05:00:01, 05:00:59) both pass the guard
+ * when the first work item failed fast and cleared engine.js's active-dedup
+ * check.
+ *
  * @param {{ cron: string }} schedule
  * @param {string|null} lastRunAt -- ISO timestamp of last run
  * @returns {boolean}
@@ -90,11 +104,17 @@ function shouldRunNow(schedule, lastRunAt) {
   const now = new Date();
   if (!cron.matches(now)) return false;
 
-  // Don't fire again if already ran within the last 55 seconds
-  // (uses elapsed time instead of field comparison to handle DST/clock adjustments)
+  // Don't fire twice in the same calendar minute (same cron window).
   if (lastRunAt) {
     const last = new Date(lastRunAt);
-    if (Date.now() - last.getTime() < 55000) return false;
+    if (!isNaN(last.getTime()) &&
+        last.getFullYear() === now.getFullYear() &&
+        last.getMonth() === now.getMonth() &&
+        last.getDate() === now.getDate() &&
+        last.getHours() === now.getHours() &&
+        last.getMinutes() === now.getMinutes()) {
+      return false;
+    }
   }
 
   return true;
@@ -121,8 +141,9 @@ function discoverScheduledWork(config) {
       const lastRun = typeof runEntry === 'string' ? runEntry : (runEntry?.lastRun || null);
       if (!shouldRunNow(sched, lastRun)) continue;
 
+      const workItemId = `sched-${sched.id}-${Date.now()}`;
       work.push({
-        id: `sched-${sched.id}-${Date.now()}`,
+        id: workItemId,
         title: sched.title,
         type: sched.type || 'implement',
         priority: sched.priority || 'medium',
@@ -135,9 +156,14 @@ function discoverScheduledWork(config) {
         _scheduleId: sched.id,
       });
 
-      // Record run time inside the lock — preserve existing fields (lastWorkItemId, lastResult, etc.)
+      // Record run time AND work-item ID at dispatch time — preserve existing
+      // completion fields (lastResult, lastCompletedAt). Writing lastWorkItemId
+      // here (not only on completion) keeps the schedule-runs entry durable if
+      // the dispatched work item crashes or the engine restarts before
+      // lifecycle.runPostCompletionHooks runs. This is the fix that closes
+      // the double-fire window alongside the same-minute guard (W-mo3zu273f8tm).
       const existing = typeof runs[sched.id] === 'object' && runs[sched.id] ? runs[sched.id] : {};
-      runs[sched.id] = { ...existing, lastRun: ts() };
+      runs[sched.id] = { ...existing, lastRun: ts(), lastWorkItemId: workItemId };
     }
   }, { defaultValue: {} });
 

package/engine/shared.js

@@ -1029,6 +1029,82 @@ function sanitizeBranch(name) {
   return String(name).replace(/[^a-zA-Z0-9._\-\/]/g, '-').slice(0, 200);
 }
 
+// ── Project Name / Path Validation (SEC-04 / SEC-05) ─────────────────────────
+// Enforced at API boundaries (e.g. POST /api/projects/add). Callers that skip
+// these validators leak caller-controlled strings into worktree paths, config
+// keys, and shell invocations — never bypass them for "internal" callers.
+
+const PROJECT_NAME_RE = /^[a-zA-Z0-9_\-]{1,64}$/;
+
+function _httpError(status, message, extra) {
+  const err = new Error(message);
+  err.statusCode = status;
+  if (extra) Object.assign(err, extra);
+  return err;
+}
+
+/**
+ * Validate a project name against a strict allowlist before it ever reaches
+ * filesystem paths, config keys, or shell arguments.
+ *
+ * Allowlist: `/^[a-zA-Z0-9_\-]{1,64}$/` (letters, digits, underscore, hyphen).
+ * Rejects anything else — path separators, dots, whitespace, shell
+ * metacharacters, null bytes. Returns the validated name; throws a 400 Error.
+ */
+function validateProjectName(name) {
+  if (typeof name !== 'string' || name.length === 0) {
+    throw _httpError(400, 'Invalid project name: name is required and must be a string');
+  }
+  if (name.length > 64) {
+    throw _httpError(400, `Invalid project name: "${name}" is ${name.length} characters (max 64)`);
+  }
+  if (!PROJECT_NAME_RE.test(name)) {
+    throw _httpError(400, `Invalid project name: "${name}". Must match /^[a-zA-Z0-9_\\-]{1,64}$/ (letters, digits, underscore, hyphen; no path separators, spaces, or shell metacharacters)`);
+  }
+  return name;
+}
+
+/**
+ * Validate a project path before it is persisted to config.json or used as a
+ * worktree parent.
+ *
+ * Default requires `fs.existsSync(path.join(pathStr, '.git'))` — accepts either
+ * a `.git` directory (normal repo) or a `.git` file (worktree pointer).
+ *
+ * To register a non-repo path, the caller must pass BOTH
+ *   `allowNonRepo: true`
+ *   `confirmToken: <uuid>`
+ * and supply an `isValidToken(token)` callback that consumes/validates the
+ * token against a freshly generated server-side token. This prevents a
+ * single POST from silently creating a broken project entry and forces the
+ * client through an explicit confirmation step (D-5: Rebecca / UUID vote).
+ *
+ * Returns the resolved absolute path; throws a 400 Error (with
+ * `needsConfirmation: true` when the only problem is the missing `.git`).
+ */
+function validateProjectPath(pathStr, options = {}) {
+  if (typeof pathStr !== 'string' || pathStr.length === 0) {
+    throw _httpError(400, 'Invalid project path: path is required and must be a string');
+  }
+  const resolved = path.resolve(pathStr);
+  if (!fs.existsSync(resolved)) {
+    throw _httpError(400, `Invalid project path: directory does not exist: ${resolved}`);
+  }
+  const gitMarker = path.join(resolved, '.git');
+  if (fs.existsSync(gitMarker)) return resolved; // .git dir OR worktree .git file
+
+  // Not a git repo — only accept with explicit confirmation.
+  const { allowNonRepo, confirmToken, isValidToken } = options;
+  if (allowNonRepo === true && typeof confirmToken === 'string' && typeof isValidToken === 'function' && isValidToken(confirmToken)) {
+    return resolved;
+  }
+  throw _httpError(
+    400,
+    `Invalid project path: "${resolved}" is not a git repository (no .git directory or file). Retry with allowNonRepo:true and a confirmToken from POST /api/projects/confirm-token to override.`,
+    { needsConfirmation: true },
+  );
+}
+
 // ── Skill Frontmatter Parser ─────────────────────────────────────────────────
 
 function parseSkillFrontmatter(content, filename) {
@@ -1631,6 +1707,8 @@ module.exports = {
   getAdoOrgBase,
   sanitizePath,
   sanitizeBranch,
+  validateProjectName,
+  validateProjectPath,
   validatePid,
   parseSkillFrontmatter,
   sleepMs,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yemi33/minions",
-  "version": "0.1.1120",
+  "version": "0.1.1122",
   "description": "Multi-agent AI dev team that runs from ~/.minions/ — five autonomous agents share a single engine, dashboard, and knowledge base",
   "bin": {
     "minions": "bin/minions.js"