@goodandready/dsh-goal 0.2.28 → 0.2.29

package/lib/engine-verification.js

@@ -1,39 +1,209 @@
 import { spawnSync } from 'node:child_process';
 import { getSafeCwd } from './goal-engine-constants.js';
 
+export const SAFE_ENV_WHITELIST = [
+  'PATH',
+  'HOME',
+  'USER',
+  'LOGNAME',
+  'LANG',
+  'LC_ALL',
+  'LC_CTYPE',
+  'SHELL',
+  'TERM',
+  'TMPDIR',
+  'TMP',
+  'TEMP',
+  'NODE_ENV',
+];
+
+const FORBIDDEN_SECRET_REGEX = /(TOKEN|KEY|SECRET|AUTH|PASS|PASSWORD|CREDENTIAL|PRIVATE|BEARER|API)/i;
+
+export const DISALLOWED_BINARIES = new Set([
+  'curl', 'wget', 'nc', 'ncat', 'netcat', 'telnet',
+  'ssh', 'scp', 'sftp', 'ftp', 'rsync',
+  'rm', 'dd', 'mkfs', 'shutdown', 'reboot', 'killall', 'kill',
+]);
+
+export const SHELL_OPERATORS = new Set([';', '&&', '||', '|', '&', '>', '>>', '<', '`']);
+
+/**
+ * Sanitize environment for child verification processes, strictly stripping tokens and secrets
+ * @param {object} [userEnv={}]
+ * @returns {object}
+ */
+export function sanitizeVerificationEnv(userEnv = {}) {
+  const clean = {};
+  for (const key of SAFE_ENV_WHITELIST) {
+    if (process.env[key] !== undefined && !FORBIDDEN_SECRET_REGEX.test(key)) {
+      clean[key] = process.env[key];
+    }
+  }
+  if (userEnv && typeof userEnv === 'object') {
+    for (const [k, v] of Object.entries(userEnv)) {
+      if (k && !FORBIDDEN_SECRET_REGEX.test(k) && v !== undefined && v !== null) {
+        clean[k] = String(v);
+      }
+    }
+  }
+  if (!clean.NODE_ENV) {
+    clean.NODE_ENV = 'test';
+  }
+  return clean;
+}
+
+/**
+ * Parse a command string or array into an argv list
+ * @param {string|string[]} commandStr
+ * @returns {string[]}
+ */
+export function parseCommandArgv(commandStr) {
+  if (Array.isArray(commandStr)) {
+    return commandStr.map(String).filter((s) => s.trim().length > 0);
+  }
+  if (!commandStr || typeof commandStr !== 'string') return [];
+  const trimmed = commandStr.trim();
+  if (!trimmed) return [];
+
+  const regex = /"([^"\\]*(?:\\.[^"\\]*)*)"|'([^'\\]*(?:\\.[^'\\]*)*)'|(\S+)/g;
+  const args = [];
+  let match;
+  while ((match = regex.exec(trimmed)) !== null) {
+    if (match[1] !== undefined) {
+      args.push(match[1].replace(/\\"/g, '"'));
+    } else if (match[2] !== undefined) {
+      args.push(match[2].replace(/\\'/g, "'"));
+    } else if (match[3] !== undefined) {
+      args.push(match[3]);
+    }
+  }
+  return args;
+}
+
+/**
+ * Validate a verification command for dangerous operators, shell chaining, or exfiltration binaries
+ * @param {string|string[]} command
+ * @returns {{ valid: boolean, error?: string, argv?: string[], binary?: string }}
+ */
+export function validateVerificationCommand(command) {
+  if (!command) return { valid: false, error: 'Empty or invalid verification command' };
+  const argv = parseCommandArgv(command);
+  if (argv.length === 0) return { valid: false, error: 'Empty or invalid verification command' };
+
+  const rawBinary = argv[0].toLowerCase().replace(/^.*[/\\]/, '');
+  if (DISALLOWED_BINARIES.has(rawBinary)) {
+    return { valid: false, error: `Execution blocked: disallowed command binary "${rawBinary}"` };
+  }
+
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i];
+    if (SHELL_OPERATORS.has(arg)) {
+      return { valid: false, error: `Execution blocked: shell operator "${arg}" is not allowed` };
+    }
+    if (arg.startsWith('$(') || (arg.startsWith('`') && arg.endsWith('`'))) {
+      return { valid: false, error: 'Execution blocked: subshell substitution is not allowed' };
+    }
+    if (i > 0 && DISALLOWED_BINARIES.has(arg.toLowerCase().replace(/^.*[/\\]/, ''))) {
+      return { valid: false, error: `Execution blocked: disallowed binary "${arg}" in arguments` };
+    }
+  }
+
+  return { valid: true, argv, binary: rawBinary };
+}
+
 /**
  * Execute a verification command in a confined working directory with timeout and output capture
- * @param {string} command Shell command to execute
+ * Uses sanitized environment (no secrets/tokens) and shell: false (no shell injection)
+ * @param {string|string[]} command Command to execute
  * @param {string} [targetCwd] Working directory
  * @param {object} [options]
  * @param {number} [options.timeoutMs=30000] Timeout in milliseconds
  * @param {number} [options.maxBuffer=1048576] Max stdout/stderr buffer in bytes (1MB)
- * @param {object} [options.env={}] Additional environment variables
+ * @param {object} [options.env={}] Additional environment variables (sanitized)
+ * @param {Function} [options.checkApproval] Custom approval check function
+ * @param {object} [options.approvalGate] ApprovalGate service instance
  * @returns {{ ok: boolean, exitCode: number, stdout: string, stderr: string, error?: string }}
  */
 export function runMilestoneVerification(command, targetCwd, options = {}) {
-  if (!command || typeof command !== 'string' || !command.trim()) {
+  const validation = validateVerificationCommand(command);
+  if (!validation.valid) {
     return {
       ok: false,
       exitCode: 1,
       stdout: '',
       stderr: '',
-      error: 'Empty or invalid verification command',
+      error: validation.error || 'Empty or invalid verification command',
     };
   }
 
   const safeCwd = getSafeCwd(targetCwd) || process.cwd();
   const timeoutMs = typeof options.timeoutMs === 'number' ? options.timeoutMs : 30000;
   const maxBuffer = typeof options.maxBuffer === 'number' ? options.maxBuffer : 1024 * 1024;
+  const { argv, binary } = validation;
+
+  // 1. Approval seam check
+  if (typeof options.checkApproval === 'function') {
+    const decision = options.checkApproval({
+      command,
+      argv,
+      binary,
+      cwd: safeCwd,
+    });
+    if (decision && (decision.kind === 'deny' || decision.deny)) {
+      return {
+        ok: false,
+        exitCode: 1,
+        stdout: '',
+        stderr: '',
+        error: `Verification command denied by policy: ${decision.reason || 'denied'}`,
+      };
+    }
+    if (decision && (decision.kind === 'ask' || decision.ask)) {
+      return {
+        ok: false,
+        exitCode: 1,
+        stdout: '',
+        stderr: '',
+        error: `Verification command requires operator approval: ${decision.reason || 'approval required'}`,
+      };
+    }
+  }
+
+  if (options.approvalGate && typeof options.approvalGate.checkCommand === 'function') {
+    try {
+      const decision = options.approvalGate.checkCommand(command, safeCwd);
+      if (decision && (decision.verdict === 'deny' || decision.verdict === 'ask')) {
+        return {
+          ok: false,
+          exitCode: 1,
+          stdout: '',
+          stderr: '',
+          error: `Verification command blocked by approval gate: ${decision.reason || decision.verdict}`,
+        };
+      }
+    } catch (err) {
+      return {
+        ok: false,
+        exitCode: 1,
+        stdout: '',
+        stderr: '',
+        error: `Approval check error: ${err?.message || err}`,
+      };
+    }
+  }
+
+  // 2. Environment sanitization (strictly scrub secrets and tokens)
+  const cleanEnv = sanitizeVerificationEnv(options.env);
 
+  // 3. Execution without shell (shell: false)
   try {
-    const res = spawnSync(command.trim(), {
-      shell: true,
+    const res = spawnSync(argv[0], argv.slice(1), {
+      shell: false,
       cwd: safeCwd,
       timeout: timeoutMs,
       maxBuffer,
       encoding: 'utf8',
-      env: { ...process.env, ...options.env },
+      env: cleanEnv,
     });
 
     if (res.error) {

package/lib/goal-engine.js

@@ -38,6 +38,8 @@ export class GoalEngine {
     this.enableMilestoneDependencies = options.enableMilestoneDependencies ?? true;
     this.soundScheme = options.soundScheme ?? 'default';
     this.enableVoiceAnnouncements = options.enableVoiceAnnouncements ?? false;
+    this.approvalGate = options.approvalGate || null;
+    this.checkApproval = options.checkApproval || null;
     this.maxSessions = options.maxSessions ?? 100;
     this.goals = new Map();
     this.listeners = new Set();
@@ -359,7 +361,7 @@ export class GoalEngine {
     if (!target) return false;
 
     if (status === MilestoneStatus.COMPLETED && target.verificationCommand) {
-      const vRes = verifyMilestoneAcceptance(target, goal.cwd || process.cwd(), goal, recordActivity);
+      const vRes = verifyMilestoneAcceptance(target, goal.cwd || process.cwd(), goal, recordActivity, { approvalGate: this.approvalGate, checkApproval: this.checkApproval });
       if (!vRes.ok) {
         this.emit(sid);
         return false;

package/lib/index.js

@@ -121,6 +121,7 @@ export function apply(ctx, config = {}) {
   const milestoneManager = new MilestoneManager(addonStore, {
     gitSnapshotManager,
     enforceDependencies: currentSettings.enableMilestoneDependencies,
+    approvalGate: safeService(ctx, "approvalGate"),
     logger,
   });
   const tokenBudgetGuard = new TokenBudgetGuard({
@@ -167,6 +168,7 @@ export function apply(ctx, config = {}) {
       autoScaleBudgetNearCompletion: currentSettings.autoScaleBudgetNearCompletion,
       enableTemplatesDrawer: currentSettings.enableTemplatesDrawer,
       enableMilestoneDependencies: currentSettings.enableMilestoneDependencies,
+      approvalGate: safeService(ctx, "approvalGate"),
       logger,
     });
     registerPlanModeGuard(ctx, { engine: fallbackEngine, logger });

package/lib/milestone-manager.js

@@ -1,14 +1,16 @@
 import { syncMilestoneWithIssue } from './engine-issue-sync.js';
-import { runMilestoneVerification } from './engine-verification.js';
+import { runMilestoneVerification, validateVerificationCommand } from './engine-verification.js';
 
 /**
  * Milestone and checklist coordinator for active core goals
  */
 export class MilestoneManager {
-  constructor(addonStore, { gitSnapshotManager = null, enforceDependencies = true, logger = console } = {}) {
+  constructor(addonStore, { gitSnapshotManager = null, enforceDependencies = true, approvalGate = null, checkApproval = null, logger = console } = {}) {
     this.store = addonStore;
     this.gitSnapshotManager = gitSnapshotManager;
     this.enforceDependencies = enforceDependencies;
+    this.approvalGate = approvalGate;
+    this.checkApproval = checkApproval;
     this.logger = logger;
   }
 
@@ -80,7 +82,10 @@ export class MilestoneManager {
 
     // Acceptance Gate (Critic Verification) - Issue #163
     if (m.verificationCommand) {
-      const vResult = runMilestoneVerification(m.verificationCommand, workspaceRoot);
+      const vResult = runMilestoneVerification(m.verificationCommand, workspaceRoot, {
+        approvalGate: this.approvalGate,
+        checkApproval: this.checkApproval,
+      });
       if (!vResult.ok) {
         m.verificationError = vResult.error;
         m.verificationOutput = (vResult.stderr || vResult.stdout || '').trim();

package/lib/tools.js

@@ -1,3 +1,4 @@
+import { validateVerificationCommand } from './engine-verification.js';
 import { MilestoneManager } from './milestone-manager.js';
 import { AddonStore } from './addon-store.js';
 import { getSafeCwd } from './goal-engine-constants.js';
@@ -67,16 +68,30 @@ export function registerTools(ctx, { milestoneManager, goalsService, logger = co
       }
 
       if (action === 'set') {
+        if (Array.isArray(args.milestones)) {
+          for (const m of args.milestones) {
+            const vCmd = m && (m.verificationCommand || m.verification_command);
+            if (vCmd) {
+              const val = validateVerificationCommand(vCmd);
+              if (!val.valid) throw new Error(`Invalid verificationCommand: ${val.error}`);
+            }
+          }
+        }
         const list = mm.setMilestones(goalId, args.milestones);
         return { ok: true, goalId, count: list.length, milestones: list };
       }
 
       if (action === 'add') {
+        const vCmd = args.verificationCommand || args.verification_command;
+        if (vCmd) {
+          const val = validateVerificationCommand(vCmd);
+          if (!val.valid) throw new Error(`Invalid verificationCommand: ${val.error}`);
+        }
         const item = mm.addMilestone(goalId, {
           title: args.title,
           checklist: args.checklist,
           dependsOn: args.dependsOn || args.depends_on,
-          verificationCommand: args.verificationCommand || args.verification_command,
+          verificationCommand: vCmd,
         });
         return { ok: true, goalId, milestone: item };
       }
@@ -196,6 +211,11 @@ export function registerTools(ctx, { milestoneManager, goalsService, logger = co
           if (typeof item === 'string') {
             return { id: `m-${idx + 1}`, title: item };
           }
+          const vCmd = item && (item.verificationCommand || item.verification_command);
+          if (vCmd) {
+            const val = validateVerificationCommand(vCmd);
+            if (!val.valid) throw new Error(`Invalid verificationCommand: ${val.error}`);
+          }
           return item;
         });
       } else {
@@ -230,6 +250,11 @@ export function registerTools(ctx, { milestoneManager, goalsService, logger = co
       const status = args.status || 'in_progress';
       const notes = typeof args.notes === 'string' ? args.notes : '';
       if (!milestoneId) throw new Error('milestone_id is required');
+      const vCmd = args.verificationCommand || args.verification_command;
+      if (vCmd) {
+        const val = validateVerificationCommand(vCmd);
+        if (!val.valid) throw new Error(`Invalid verificationCommand: ${val.error}`);
+      }
       if (status === 'completed') {
         const rawCwd = toolCtx?.session?.cwd || toolCtx?.cwd || process.cwd();
         const safeCwd = getSafeCwd(rawCwd);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goodandready/dsh-goal",
-  "version": "0.2.28",
+  "version": "0.2.29",
   "description": "Core Goal Addon (Token Budget, Milestones, Git Snapshots & Retrospective Reports) for DeepSeek Harness",
   "type": "module",
   "main": "./lib/index.js",