forge-workflow 0.0.5 → 0.0.6

package/lib/commands/_registry.js

@@ -0,0 +1,134 @@
+/**
+ * Command Registry — Auto-Discovery
+ *
+ * Scans a commands directory for .js files, validates each exports
+ * { name, description, handler }, and builds a routing Map.
+ *
+ * Follows the same fs.readdirSync() pattern as lib/plugin-manager.js.
+ *
+ * @module _registry
+ */
+
+const { existsSync, readdirSync } = require('node:fs');
+const path = require('node:path');
+
+/**
+ * @typedef {Object} CommandModule
+ * @property {string} name - Command name used for routing
+ * @property {string} description - Human-readable description
+ * @property {function(Array, Object, string): Promise<*>} handler - Async command handler
+ * @property {string} [usage] - Usage string (optional)
+ * @property {Object<string, string>} [flags] - Flag descriptions (optional)
+ */
+
+/**
+ * Validate that a module exports the required command interface.
+ *
+ * @param {*} mod - The required module
+ * @returns {{ valid: boolean, reason?: string }}
+ */
+function validateCommand(mod) {
+  if (!mod || typeof mod !== 'object') {
+    return { valid: false, reason: 'module does not export an object' };
+  }
+  if (typeof mod.name !== 'string' || !mod.name) {
+    return { valid: false, reason: 'missing or invalid "name" export' };
+  }
+  if (typeof mod.description !== 'string' || !mod.description) {
+    return { valid: false, reason: 'missing or invalid "description" export' };
+  }
+  if (typeof mod.handler !== 'function') {
+    return { valid: false, reason: 'missing or invalid "handler" export' };
+  }
+  return { valid: true };
+}
+
+/**
+ * Load and discover command modules from a directory.
+ *
+ * Scans `commandsDir` for `.js` files (excluding files starting with `_`),
+ * validates each module exports `{ name, description, handler }`, and builds
+ * a routing Map keyed by command name.
+ *
+ * Malformed modules are skipped with a `console.warn` — other commands
+ * continue loading. Duplicate command names warn and skip the later file.
+ *
+ * @param {string} commandsDir - Absolute path to the commands directory
+ * @returns {{ commands: Map<string, CommandModule>, getHelp: () => string }}
+ */
+function loadCommands(commandsDir) {
+  /** @type {Map<string, CommandModule>} */
+  const commands = new Map();
+
+  if (!commandsDir || !existsSync(commandsDir)) {
+    return {
+      commands,
+      getHelp: () => buildHelp(commands),
+    };
+  }
+
+  const files = readdirSync(commandsDir)
+    .filter(f => f.endsWith('.js') && !f.startsWith('_'))
+    .sort(); // deterministic order — first file wins on duplicates
+
+  for (const file of files) {
+    const filePath = path.join(commandsDir, file);
+
+    let mod;
+    try {
+      mod = require(filePath);
+    } catch (_err) {
+      console.warn(`[registry] Skipping ${file}: failed to load — ${_err.message}`);
+      continue;
+    }
+
+    const validation = validateCommand(mod);
+    if (!validation.valid) {
+      console.warn(`[registry] Skipping ${file}: ${validation.reason}`);
+      continue;
+    }
+
+    if (commands.has(mod.name)) {
+      console.warn(
+        `[registry] Skipping ${file}: duplicate command name "${mod.name}"`
+      );
+      continue;
+    }
+
+    commands.set(mod.name, mod);
+  }
+
+  return {
+    commands,
+    getHelp: () => buildHelp(commands),
+  };
+}
+
+/**
+ * Build a formatted help string from discovered commands.
+ *
+ * @param {Map<string, CommandModule>} commands
+ * @returns {string}
+ */
+function buildHelp(commands) {
+  if (commands.size === 0) {
+    return 'No commands available.';
+  }
+
+  const lines = ['Available commands:', ''];
+
+  // Find the longest name for alignment
+  let maxLen = 0;
+  for (const name of commands.keys()) {
+    if (name.length > maxLen) maxLen = name.length;
+  }
+
+  for (const [name, cmd] of commands) {
+    const padding = ' '.repeat(maxLen - name.length + 2);
+    lines.push(`  ${name}${padding}${cmd.description}`);
+  }
+
+  return lines.join('\n');
+}
+
+module.exports = { loadCommands, validateCommand };

package/lib/commands/clean.js

@@ -0,0 +1,181 @@
+'use strict';
+
+const { execFileSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+const { stopDolt } = require('./worktree');
+
+/**
+ * Forge Clean Command
+ * Remove worktrees for merged branches, stopping Dolt servers first.
+ * Uses execFileSync (not execSync) to prevent command injection (OWASP A03).
+ *
+ * @module commands/clean
+ */
+
+/**
+ * Detect the default branch (main, master, develop, trunk).
+ * Tries origin/HEAD first, then probes common names.
+ * @param {Function} runFile - execFileSync-compatible function
+ * @returns {string} Default branch name
+ */
+function getDefaultBranch(runFile) {
+  try {
+    return runFile('git', ['rev-parse', '--abbrev-ref', 'origin/HEAD'], { stdio: 'pipe' })
+      .toString().trim().replace('origin/', '');
+  } catch (_e) { /* intentional: origin/HEAD not set, probe common names */ // NOSONAR S2486
+    for (const name of ['main', 'master', 'develop', 'trunk']) {
+      try {
+        runFile('git', ['rev-parse', '--verify', name], { stdio: 'pipe' });
+        return name;
+      } catch (_e2) { /* intentional: try next branch name */ } // NOSONAR S2486
+    }
+    return 'main';
+  }
+}
+
+/**
+ * Parse `git worktree list --porcelain` output into a map of path -> branch.
+ * @param {string} output - Raw porcelain output
+ * @returns {Map<string, string>} Map of worktree path -> branch name
+ */
+function parseWorktreeList(output) {
+  const map = new Map();
+  const blocks = output.split('\n\n');
+  for (const block of blocks) {
+    const lines = block.trim().split('\n');
+    let wtPath = null;
+    let branch = null;
+    for (const line of lines) {
+      if (line.startsWith('worktree ')) {
+        wtPath = line.slice('worktree '.length);
+      }
+      if (line.startsWith('branch ')) {
+        // branch refs/heads/feat/foo -> feat/foo
+        branch = line.slice('branch refs/heads/'.length);
+      }
+    }
+    if (wtPath && branch) {
+      map.set(wtPath, branch);
+    }
+  }
+  return map;
+}
+
+/**
+ * Clean a single worktree directory if its branch is merged.
+ * @param {string} dir - Directory name within .worktrees/
+ * @param {Map<string, string>} worktreeMap - Path-to-branch mapping
+ * @param {string[]} mergedBranches - List of merged branch names
+ * @param {string} worktreesDir - Absolute path to .worktrees/
+ * @param {boolean} dryRun - If true, skip actual removal
+ * @param {Function} runFile - execFileSync-compatible function
+ * @param {object} fsApi - fs module (for DI)
+ * @returns {Promise<boolean>} True if the worktree was cleaned (or would be in dry-run)
+ */
+async function cleanWorktree(dir, worktreeMap, mergedBranches, worktreesDir, dryRun, runFile, fsApi) {
+  const wtPath = path.resolve(worktreesDir, dir);
+  const branch = worktreeMap.get(wtPath);
+
+  if (branch && mergedBranches.includes(branch)) {
+    if (!dryRun) {
+      const stopResult = stopDolt(wtPath, { _exec: runFile, _fs: fsApi });
+      if (stopResult.stopped) {
+        await new Promise(r => setTimeout(r, 500));
+      }
+      try {
+        runFile('git', ['worktree', 'remove', wtPath], { stdio: 'pipe' });
+      } catch (_removeErr) { /* intentional: worktree has uncommitted changes, skip */ // NOSONAR S2486
+        return false;
+      }
+    }
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Main handler for the clean command.
+ * @param {string[]} _args - Positional arguments (unused)
+ * @param {object} flags - CLI flags
+ * @param {string} projectRoot - Project root path
+ * @param {object} [opts] - Options for dependency injection
+ * @param {Function} [opts._exec] - Override for execFileSync (testing)
+ * @param {object} [opts._fs] - Override for fs module (testing)
+ * @returns {Promise<{ success: boolean, cleaned: number, active: number, dryRun: boolean }>}
+ */
+async function handler(_args, flags, projectRoot, opts = {}) {
+  const runFile = opts._exec || execFileSync;
+  const fsApi = opts._fs || fs;
+  const dryRun = !!(flags['--dry-run'] || flags.dryRun);
+
+  const worktreesDir = path.resolve(projectRoot, '.worktrees');
+
+  // If .worktrees/ doesn't exist, nothing to clean
+  if (!fsApi.existsSync(worktreesDir)) {
+    return { success: true, cleaned: 0, active: 0, dryRun };
+  }
+
+  // 1. List dirs in .worktrees/
+  const entries = fsApi.readdirSync(worktreesDir, { withFileTypes: true });
+  const dirs = entries.filter(e => e.isDirectory()).map(e => e.name);
+
+  if (dirs.length === 0) {
+    return { success: true, cleaned: 0, active: 0, dryRun };
+  }
+
+  // 2. Detect default branch, then get merged branches
+  const defaultBranch = getDefaultBranch(runFile);
+  let mergedBranches;
+  try {
+    const mergedOutput = runFile('git', ['branch', '--merged', defaultBranch], { stdio: 'pipe' });
+    mergedBranches = mergedOutput
+      .toString()
+      .split('\n')
+      .map(b => b.trim().replace(/^\*\s*/, ''))
+      .filter(b => b.length > 0);
+  } catch (_e) { /* intentional: fallback to empty list */ // NOSONAR S2486
+    mergedBranches = [];
+  }
+
+  // 3. Get worktree -> branch mapping from git
+  let worktreeMap;
+  try {
+    const listOutput = runFile('git', ['worktree', 'list', '--porcelain'], { stdio: 'pipe' });
+    worktreeMap = parseWorktreeList(listOutput.toString());
+  } catch (_e) { /* intentional: fallback to empty map */ // NOSONAR S2486
+    worktreeMap = new Map();
+  }
+
+  // 4. For each worktree dir, check if its branch is merged
+  let cleaned = 0;
+  let active = 0;
+
+  for (const dir of dirs) {
+    const wasCleaned = await cleanWorktree(dir, worktreeMap, mergedBranches, worktreesDir, dryRun, runFile, fsApi);
+    if (wasCleaned) {
+      cleaned++;
+    } else {
+      active++;
+    }
+  }
+
+  // Prune stale worktree refs to prevent bare repo state
+  if (!dryRun && cleaned > 0) {
+    try {
+      runFile('git', ['worktree', 'prune'], { stdio: 'pipe' });
+    } catch (_e) { /* intentional: prune is best-effort cleanup */ } // NOSONAR S2486
+  }
+
+  return { success: true, cleaned, active, dryRun };
+}
+
+module.exports = {
+  name: 'clean',
+  description: 'Remove worktrees for merged branches (stops Dolt servers)',
+  usage: 'forge clean [--dry-run]',
+  flags: {
+    '--dry-run': 'Show what would be cleaned without removing',
+  },
+  handler,
+};

package/lib/commands/dev.js

@@ -500,6 +500,63 @@ function calculateDecisionRoute(score, dimensions) {
 	return { route: DECISION_ROUTES.BLOCKED, score: effectiveScore };
 }
 
+/**
+ * Verify task completion and auto-commit changes if needed.
+ *
+ * Checks for uncommitted changes, stages only scoped files, commits,
+ * and returns the result. NEVER uses `git add -A` or `git add .`.
+ *
+ * Security: Uses execFileSync only (OWASP A03 — no shell injection).
+ *
+ * @param {string} taskTitle - The task title for the commit message
+ * @param {string[]|null|undefined} ownedFiles - Files this task owns (scoped staging). If falsy, stages tracked modified files only.
+ * @param {object} [opts] - Options
+ * @param {Function} [opts._exec] - Injected execFileSync for testing
+ * @returns {{committed: boolean, autoCommitted: boolean, commitSha: string|null, hasChanges: boolean}}
+ * @example
+ * const result = verifyTaskCompletion('add login form', ['lib/auth.js'], { _exec: mockExec });
+ */
+function verifyTaskCompletion(taskTitle, ownedFiles, opts = {}) {
+	const run = opts._exec || execFileSync;
+
+	// 1. Check for uncommitted changes
+	const status = run('git', ['status', '--porcelain']).toString().trim();
+
+	if (!status) {
+		return { committed: false, autoCommitted: false, commitSha: null, hasChanges: false };
+	}
+
+	// There are changes
+	let filesToStage = [];
+
+	if (ownedFiles && ownedFiles.length > 0) {
+		// 2. Stage only owned files — NEVER git add -A
+		filesToStage = ownedFiles;
+	} else {
+		// 3. Stage only tracked modified files from git diff --name-only
+		const diffOutput = run('git', ['diff', '--name-only']).toString().trim();
+		if (diffOutput) {
+			filesToStage = diffOutput.split('\n').filter(Boolean);
+		}
+	}
+
+	// If no files to stage, skip commit
+	if (filesToStage.length === 0) {
+		return { committed: false, autoCommitted: false, commitSha: null, hasChanges: true };
+	}
+
+	// Stage scoped files
+	run('git', ['add', ...filesToStage]);
+
+	// 4. Commit with standardized message
+	run('git', ['commit', '-m', `feat(task): ${taskTitle}`]);
+
+	// 5. Get commit sha
+	const commitSha = run('git', ['log', '-1', '--format=%H']).toString().trim();
+
+	return { committed: true, autoCommitted: true, commitSha, hasChanges: true };
+}
+
 module.exports = {
 	detectTDDPhase,
 	identifyFilePairs,
@@ -510,4 +567,5 @@ module.exports = {
 	executeDev,
 	calculateDecisionRoute,
 	DECISION_ROUTES,
+	verifyTaskCompletion,
 };

package/lib/commands/push.js

@@ -0,0 +1,196 @@
+'use strict';
+
+const { execFileSync, spawnSync } = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+const forgeToken = require('../../scripts/check-forge-token');
+
+const isWindows = process.platform === 'win32';
+
+/**
+ * Detect package manager from lock files.
+ * Same priority order as scripts/test.js.
+ *
+ * @param {string} projectRoot - Absolute path to project root
+ * @param {function} [existsSync] - Injected fs.existsSync for testing
+ * @returns {string} Package manager command name
+ */
+function detectPackageManager(projectRoot, existsSync = fs.existsSync) {
+	if (existsSync(path.join(projectRoot, 'bun.lockb')) || existsSync(path.join(projectRoot, 'bun.lock'))) return 'bun';
+	if (existsSync(path.join(projectRoot, 'pnpm-lock.yaml'))) return 'pnpm';
+	if (existsSync(path.join(projectRoot, 'yarn.lock'))) return 'yarn';
+	return 'npm';
+}
+
+/**
+ * Get the current git branch name.
+ *
+ * @param {function} execFn - execFileSync or mock
+ * @returns {string} Current branch name
+ */
+function getCurrentBranch(execFn) {
+	try {
+		return execFn('git', ['branch', '--show-current'], { encoding: 'utf8' }).trim();
+	} catch (_err) { /* intentional: fallback to 'unknown' */ // NOSONAR S2486
+		return 'unknown';
+	}
+}
+
+/**
+ * Check if this is the first push to the current branch.
+ * If `git rev-list --count origin/<branch>` throws, the remote tracking
+ * branch doesn't exist yet — meaning this is a first push.
+ *
+ * @param {string} branch - Branch name
+ * @param {function} execFn - execFileSync or mock
+ * @returns {boolean} True if first push (no remote tracking branch)
+ */
+function isFirstPush(branch, execFn) {
+	try {
+		execFn('git', ['rev-list', '--count', 'origin/' + branch], { encoding: 'utf8' });
+		return false;
+	} catch (_err) { /* intentional: no remote tracking branch means first push */ // NOSONAR S2486
+		return true;
+	}
+}
+
+/**
+ * Run branch protection check as a subprocess.
+ * @param {function} execFn - execFileSync or mock
+ * @param {string} projectRoot - Absolute path to project root
+ * @param {function} log - Logger function
+ * @returns {boolean} True if branch protection passed
+ */
+function runBranchProtection(execFn, projectRoot, log) {
+	try {
+		execFn('node', [path.join(projectRoot, 'scripts', 'branch-protection.js')]);
+		return true;
+	} catch (_err) { /* intentional: fallback to failure */ // NOSONAR S2486
+		log('Branch protection check failed — push aborted.');
+		return false;
+	}
+}
+
+/**
+ * Run lint via the detected package manager.
+ * @param {function} spawnFn - spawnSync or mock
+ * @param {string} pkgManager - Package manager command
+ * @param {string} projectRoot - Absolute path to project root
+ * @returns {boolean} True if lint passed
+ */
+function runLint(spawnFn, pkgManager, projectRoot) {
+	const lintResult = spawnFn(pkgManager, ['run', 'lint'], {
+		stdio: 'inherit',
+		shell: isWindows,
+		cwd: projectRoot,
+	});
+	return lintResult.status === 0;
+}
+
+/**
+ * Run tests unless in quick mode, logging warnings for first push.
+ * @param {function} spawnFn - spawnSync or mock
+ * @param {function} execFn - execFileSync or mock
+ * @param {string} pkgManager - Package manager command
+ * @param {string} projectRoot - Absolute path to project root
+ * @param {boolean} quickMode - Whether to skip tests
+ * @param {function} log - Logger function
+ * @returns {boolean|undefined} True if tests passed, undefined if skipped
+ */
+function runTests(spawnFn, execFn, pkgManager, projectRoot, quickMode, log) {
+	if (quickMode) {
+		log('Tests skipped (--quick) — CI will run full suite on GitHub');
+		const branch = getCurrentBranch(execFn);
+		if (isFirstPush(branch, execFn)) {
+			log('Warning: First push to this branch — consider `forge push` (full suite) before merge');
+		}
+		return undefined;
+	}
+
+	const testResult = spawnFn(pkgManager, ['run', 'test'], {
+		stdio: 'inherit',
+		shell: isWindows,
+		cwd: projectRoot,
+		timeout: 120000,
+	});
+	return testResult.status === 0;
+}
+
+module.exports = {
+	name: 'push',
+	description: 'Push with quality gates (branch protection + lint + tests)',
+	usage: 'forge push [--quick] [-- <git-push-args>]',
+	flags: {
+		'--quick': 'Skip tests (lint-only) for review-cycle pushes',
+	},
+
+	/**
+	 * Push handler — runs branch protection, lint, optionally tests,
+	 * then forwards to git push.
+	 *
+	 * @param {string[]} args - Passthrough args for git push (e.g. ['-u', 'origin', 'feat/slug'])
+	 * @param {Object} flags - Parsed flags (e.g. { '--quick': true })
+	 * @param {string} projectRoot - Absolute path to project root
+	 * @param {Object} [deps] - Dependency injection for testing
+	 * @returns {Promise<{success: boolean, quickMode: boolean, lintPassed: boolean, testsPassed?: boolean, pushed: boolean}>}
+	 */
+	handler: async (args, flags, projectRoot, deps) => {
+		const execFn = deps?.execFileSync || execFileSync;
+		const spawnFn = deps?.spawnSync || spawnSync;
+		const existsFn = deps?.existsSync || fs.existsSync;
+		const log = deps?.log || console.log;
+		const tokenWrite = deps?.writeForgeToken || forgeToken.write;
+
+		const quickMode = !!(flags && (flags['--quick'] || flags.quick));
+		const pkgManager = detectPackageManager(projectRoot, existsFn);
+
+		// Step 1: Branch protection
+		const branchOk = runBranchProtection(execFn, projectRoot, log);
+		if (!branchOk) {
+			return { success: false, quickMode, lintPassed: false, pushed: false };
+		}
+
+		// Step 2: Lint
+		const lintPassed = runLint(spawnFn, pkgManager, projectRoot);
+		if (!lintPassed) {
+			log('Lint failed — push aborted.');
+			return { success: false, quickMode, lintPassed: false, pushed: false };
+		}
+
+		// Step 3: Tests (skip in quick mode)
+		const testsPassed = runTests(spawnFn, execFn, pkgManager, projectRoot, quickMode, log);
+		if (!quickMode && !testsPassed) {
+			return { success: false, quickMode, lintPassed: true, testsPassed: false, pushed: false };
+		}
+
+		// Step 4: Write nonce token so lefthook skips pre-push hooks
+		try {
+			tokenWrite(projectRoot);
+		} catch (_err) { /* intentional: non-fatal, lefthook will re-run hooks */ // NOSONAR S2486
+			log('Warning: Could not write forge push token — lefthook hooks will run again');
+		}
+
+		// Step 5: git push with passthrough args
+		const gitArgs = args.filter(a => a !== '--quick');
+		try {
+			execFn('git', ['push', ...gitArgs], { stdio: 'inherit' });
+		} catch (_pushErr) { // NOSONAR S2486
+			log('git push failed.');
+			return {
+				success: false,
+				quickMode,
+				lintPassed: true,
+				...(quickMode ? {} : { testsPassed: true }),
+				pushed: false,
+			};
+		}
+
+		return {
+			success: true,
+			quickMode,
+			lintPassed: true,
+			...(quickMode ? {} : { testsPassed: true }),
+			pushed: true,
+		};
+	},
+};

package/lib/commands/recommend.js

@@ -99,7 +99,7 @@ function formatRecommendations(recommendations) {
  * @returns {{ budgetMode: string, recommendations: Object, error?: string }}
  */
 function handleRecommend(flags, projectPath) {
-  const budgetMode = flags.budget || 'startup';
+  const budgetMode = flags.budget || 'free';
 
   // Validate budget mode
   if (!BUDGET_MODES[budgetMode]) {

package/lib/commands/sync.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const { execFileSync } = require('node:child_process');
+
+/**
+ * Forge Sync Command
+ * Syncs Beads issue data by running dolt pull + push.
+ * Uses execFileSync (not execSync) to prevent command injection (OWASP A03).
+ *
+ * @module commands/sync
+ */
+module.exports = {
+  name: 'sync',
+  description: 'Sync Beads issue data (dolt pull + push)',
+  usage: 'forge sync',
+  flags: {},
+
+  /**
+   * Run beads dolt pull + push to sync issue data.
+   * @param {string[]} _args - Positional arguments (unused)
+   * @param {object} _flags - CLI flags (unused)
+   * @param {string} _projectRoot - Project root path (unused)
+   * @param {object} [opts] - Options for dependency injection
+   * @param {Function} [opts._exec] - Override for execFileSync (testing)
+   * @returns {Promise<{success: boolean, synced: boolean, message?: string, error?: string}>}
+   */
+  handler: async (_args, _flags, _projectRoot, opts = {}) => {
+    const exec = opts._exec || execFileSync;
+
+    // Step 1: Check if bd binary exists
+    try {
+      exec('bd', ['--version'], { stdio: 'pipe' });
+    } catch (_checkErr) { /* intentional: bd not installed, skip sync gracefully */ // NOSONAR S2486
+      return {
+        success: true,
+        synced: false,
+        message: 'Beads not installed — nothing to sync',
+      };
+    }
+
+    // Step 2: Run dolt pull + push
+    try {
+      exec('bd', ['dolt', 'pull'], { stdio: 'pipe' });
+      exec('bd', ['dolt', 'push'], { stdio: 'pipe' });
+    } catch (syncErr) {
+      return {
+        success: false,
+        synced: false,
+        error: syncErr.message,
+      };
+    }
+
+    return { success: true, synced: true };
+  },
+};

package/lib/commands/team.js

@@ -0,0 +1,37 @@
+const { existsSync } = require('node:fs');
+const { execFileSync } = require('node:child_process');
+const path = require('node:path');
+
+// Resolve bash binary from fixed, known locations only (no PATH search).
+// SonarCloud S4036: PATH must not be searched for OS commands.
+function _resolveBash() {
+  if (process.platform === 'win32') {
+    // Fixed locations for Git Bash on Windows (no PATH search)
+    const candidates = [
+      'C:\\Program Files\\Git\\bin\\bash.exe',
+      'C:\\Program Files (x86)\\Git\\bin\\bash.exe',
+      `${process.env.LOCALAPPDATA || ''}\\Programs\\Git\\bin\\bash.exe`,
+    ];
+    for (const p of candidates) {
+      if (p && existsSync(p)) return p;
+    }
+    // Fallback: assume Git Bash is in PATH (less secure but functional)
+    return 'bash';
+  }
+  return '/usr/bin/bash';
+}
+
+function handleTeam(args) {
+  const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'forge-team', 'index.sh');
+  const bashPath = _resolveBash();
+
+  try {
+    execFileSync(bashPath, [scriptPath, ...args], {
+      stdio: 'inherit',
+    });
+  } catch (err) {
+    process.exit(err.status || 1);
+  }
+}
+
+module.exports = { handleTeam };